np.iinfo | np.finfo:\\n try:\\n dtype_info = np.iinfo(dtype)\\n except ValueError:\\n dtype_info = np.finfo(dtype)\\n return dtype_info\",\n \"def get_py_obj_dtype(obj):\\n\\n if isinstance(obj, (typing.Type, type)):\\n return pytype_to_dtype(obj)\\n return pytype_to_dtype(type(obj))\",\n \"def dtype():\\n return RaggedDtype()\",\n \"def convert_dtypes(rows):\\n dtype_map = {pd.Timestamp: lambda x: x.to_pydatetime(),\\n np.int8: lambda x: int(x),\\n np.int16: lambda x: int(x),\\n np.int32: lambda x: int(x),\\n np.int64: lambda x: int(x),\\n np.float16: lambda x: float(x),\\n np.float32: lambda x: float(x),\\n np.float64: lambda x: float(x),\\n np.float128: lambda x: float(x)}\\n for row in rows:\\n yield [dtype_map.get(type(elem), lambda x: x)(elem) for elem in row]\",\n \"def datatype(f):\\n from numpy import bool, uint8, uint16, int32\\n code = f.dtype\\n if code == bool: type='binary'\\n elif code == uint8: type='uint8'\\n elif code == uint16: type='uint16'\\n elif code == int32: type='int32'\\n else:\\n assert 0,'Does not accept this typecode: %s' % code\\n return type\",\n \"def infer_dtype(self):\\n raise NotImplementedError\",\n \"def dtype_int(dtype: DType):\\n # TODO: Is there a better way of doing this?\\n name = list(convert(dtype, NPDType).__name__)\\n while name and name[0] not in set([str(i) for i in range(10)]):\\n name.pop(0)\\n return _convert_back(_name_to_numpy_dtype(\\\"int\\\" + \\\"\\\".join(name)), dtype)\",\n \"def _getconv(dtype):\\n\\n\\n\\n\\ttyp = dtype.type\\n\\tif issubclass(typ, np.bool_):\\n\\t\\treturn lambda x: bool(int(x))\\n\\tif issubclass(typ, np.uint64):\\n\\t\\treturn np.uint64\\n\\tif issubclass(typ, np.int64):\\n\\t\\treturn np.int64\\n\\tif issubclass(typ, np.int32):\\n\\t\\treturn np.int32\\n\\telif issubclass(typ, np.longdouble):\\n\\t\\treturn np.longdouble\\n\\telif issubclass(typ, np.floating):\\n\\t\\treturn np.float32\\n\\telse:\\n\\t\\traise SystemExit(\\\"Incorrect data type\\\")\",\n \"def to_torch_dtype(numpy_dtype):\\n x = np.zeros([1], dtype=numpy_dtype)\\n t = torch.from_numpy(x)\\n return t.dtype\",\n \"def dtype_to_pgtype(dtype, colname):\\n if colname in ('the_geom', 'the_geom_webmercator'):\\n return 'geometry'\\n else:\\n if dtype == 'float64':\\n return 'numeric'\\n elif dtype == 'int64':\\n return 'int'\\n elif dtype == 'datetime64[ns]':\\n return 'date'\\n elif dtype == 'bool':\\n return 'boolean'\\n else:\\n return 'text'\\n\\n return None\",\n \"def typecast(dtype: Any) -> str:\\n if dtype is int:\\n return \\\"Int64\\\"\\n elif dtype is float:\\n return \\\"Float64\\\"\\n elif dtype is bool:\\n return \\\"bool\\\"\\n return \\\"string\\\"\",\n \"def _cast_unsupported_dtypes(tensor):\\n\\n if tensor.dtype.__eq__(dtypes.int64):\\n # outside-compilation doesn't support int64 input yet.\\n return math_ops.cast(tensor, dtypes.int32)\\n if tensor.dtype.__eq__(dtypes.bfloat16) or tensor.dtype.__eq__(\\n dtypes.float16):\\n # Since host can't handle bf16, convert tensor to f32.\\n return math_ops.cast(tensor, dtypes.float32)\\n return tensor\",\n \"def type_info(np_type):\\n dt = np.dtype(np_type)\\n np_type = dt.type\\n width = dt.itemsize\\n try: # integer type\\n info = np.iinfo(dt)\\n except ValueError:\\n pass\\n else:\\n return dict(min=np_type(info.min), max=np_type(info.max), minexp=None,\\n maxexp=None, nmant=None, nexp=None, width=width)\\n info = np.finfo(dt)\\n # Trust the standard IEEE types\\n nmant, nexp = info.nmant, info.nexp\\n ret = dict(min=np_type(info.min),\\n max=np_type(info.max),\\n nmant=nmant,\\n nexp=nexp,\\n minexp=info.minexp,\\n maxexp=info.maxexp,\\n width=width)\\n if np_type in (_float16, np.float32, np.float64,\\n np.complex64, np.complex128):\\n return ret\\n info_64 = np.finfo(np.float64)\\n if dt.kind == 'c':\\n assert np_type is np.longcomplex\\n vals = (nmant, nexp, width / 2)\\n else:\\n assert np_type is np.longdouble\\n vals = (nmant, nexp, width)\\n if vals in ((112, 15, 16), # binary128\\n (info_64.nmant, info_64.nexp, 8), # float64\\n (63, 15, 12), (63, 15, 16)): # Intel extended 80\\n return ret # these are OK without modification\\n # The remaining types are longdoubles with bad finfo values. Some we\\n # correct, others we wait to hear of errors.\\n # We start with float64 as basis\\n ret = type_info(np.float64)\\n if vals in ((52, 15, 12), # windows float96\\n (52, 15, 16)): # windows float128?\\n # On windows 32 bit at least, float96 is Intel 80 storage but operating\\n # at float64 precision. The finfo values give nexp == 15 (as for intel\\n # 80) but in calculations nexp in fact appears to be 11 as for float64\\n ret.update(dict(width=width))\\n return ret\\n if vals == (105, 11, 16): # correctly detected double double\\n ret.update(dict(nmant=nmant, nexp=nexp, width=width))\\n return ret\\n # Oh dear, we don't recognize the type information. Try some known types\\n # and then give up. At this stage we're expecting exotic longdouble or\\n # their complex equivalent.\\n if np_type not in (np.longdouble, np.longcomplex) or width not in (16, 32):\\n raise FloatingError('We had not expected type %s' % np_type)\\n if (vals == (1, 1, 16) and on_powerpc() and\\n _check_maxexp(np.longdouble, 1024)):\\n # double pair on PPC. The _check_nmant routine does not work for this\\n # type, hence the powerpc platform check instead\\n ret.update(dict(nmant=106, width=width))\\n elif (_check_nmant(np.longdouble, 52) and\\n _check_maxexp(np.longdouble, 11)):\\n # Got float64 despite everything\\n pass\\n elif (_check_nmant(np.longdouble, 112) and\\n _check_maxexp(np.longdouble, 16384)):\\n # binary 128, but with some busted type information. np.longcomplex\\n # seems to break here too, so we need to use np.longdouble and\\n # complexify\\n two = np.longdouble(2)\\n # See: https://matthew-brett.github.io/pydagogue/floating_point.html\\n max_val = (two ** 113 - 1) / (two ** 112) * two ** 16383\\n if np_type is np.longcomplex:\\n max_val += 0j\\n ret = dict(min=-max_val,\\n max=max_val,\\n nmant=112,\\n nexp=15,\\n minexp=-16382,\\n maxexp=16384,\\n width=width)\\n else: # don't recognize the type\\n raise FloatingError('We had not expected long double type %s '\\n 'with info %s' % (np_type, info))\\n return ret\",\n \"def ogrtype2npytype(ogrtype):\\n if ogrtype == ogr.OFTReal:\\n return np.float64\\n elif ogrtype == ogr.OFTInteger:\\n return np.int32\\n raise TypeError(\\\"OGR type cannot be mapped to a numpy dtype.\\\")\",\n \"def _parse_dtypes(data, table_meta):\\n for name, field in table_meta['fields'].items():\\n field_type = field['type']\\n if field_type == 'datetime':\\n datetime_format = field.get('format')\\n data[name] = pd.to_datetime(data[name], format=datetime_format, exact=False)\\n elif field_type == 'numerical' and field.get('subtype') == 'integer':\\n data[name] = data[name].dropna().astype(np.int64)\\n elif field_type == 'id' and field.get('subtype', 'integer') == 'integer':\\n data[name] = data[name].dropna().astype(np.int64)\\n\\n return data\",\n \"def get_dtype(arr, backend='autograd'):\\n if backend == 'pytorch':\\n return pytorch_dtype_query_mapping_dict[arr.dtype]\\n elif backend == 'autograd':\\n return str(arr.dtype)\",\n \"def np_to_pa_dtype(dtype):\\n # special case when dtype is np.datetime64\\n if dtype.kind == \\\"M\\\":\\n time_unit, _ = np.datetime_data(dtype)\\n if time_unit in (\\\"s\\\", \\\"ms\\\", \\\"us\\\", \\\"ns\\\"):\\n # return a pa.Timestamp of the appropriate unit\\n return pa.timestamp(time_unit)\\n # default is int64_t UNIX ms\\n return pa.date64()\\n elif dtype.kind == \\\"m\\\":\\n time_unit, _ = np.datetime_data(dtype)\\n if time_unit in (\\\"s\\\", \\\"ms\\\", \\\"us\\\", \\\"ns\\\"):\\n # return a pa.Duration of the appropriate unit\\n return pa.duration(time_unit)\\n # default fallback unit is ns\\n return pa.duration(\\\"ns\\\")\\n return _np_pa_dtypes[cudf.dtype(dtype).type]\",\n \"def tensor_dtype_to_storage_tensor_dtype(tensor_dtype: int) -> int:\\n return mapping.TENSOR_TYPE_MAP[tensor_dtype].storage_dtype\",\n \"def nptype2gdal(dtype):\\n if dtype == np.float32:\\n return gdal.GDT_Float32\\n elif dtype == np.float64:\\n return gdal.GDT_Float64\\n elif dtype == np.int32:\\n return gdal.GDT_Int32\\n elif dtype == np.bool or dtype == np.uint8:\\n return gdal.GDT_Byte\\n return gdal.GDT_Float64\",\n \"def _get_type(dtype):\\n if isinstance(dtype, macro):\\n dtype = dtype.as_fn()\\n \\n while isinstance(dtype, jit):\\n dtype = dtype.f \\n \\n while isinstance(dtype, Expr):\\n if isinstance(dtype, UntypedFn):\\n if len(dtype.body) == 1:\\n stmt = dtype.body[0]\\n if stmt.__class__ is Return:\\n expr = stmt.value \\n if expr.__class__ is Cast:\\n dtype = expr.type \\n break\\n assert False, \\\"Don't know how to convert function %s into Parakeet type\\\" % dtype\\n elif isinstance(dtype, TypedFn):\\n dtype = dtype.return_type\\n if isinstance(dtype, TypeValue):\\n dtype = dtype.type_value \\n elif isinstance(dtype.type, TypeValueT):\\n dtype = dtype.type\\n elif isinstance(dtype, Closure):\\n dtype = dtype.fn\\n elif isinstance(dtype.type, (ClosureT, FnT)):\\n dtype = dtype.type.fn\\n else:\\n assert False, \\\"Don't know how to turn %s : %s into Parakeet type\\\" % (dtype, dtype.type) \\n\\n\\n if isinstance(dtype, Type):\\n if isinstance(dtype, TypeValueT):\\n return dtype.type\\n else:\\n return dtype \\n \\n elif isinstance(dtype, (np.dtype, type)):\\n\\n return type_conv.equiv_type(dtype)\\n elif isinstance(dtype, str):\\n return type_conv.equiv_type(np.dtype(dtype))\\n assert False, \\\"Don't know how to turn %s into Parakeet type\\\" % dtype\",\n \"def convert_dtype(data_df, settings):\\n data_df = data_df.astype(settings[\\\"dtype\\\"])\\n return data_df\",\n \"def sql_type(dtype):\\n if dtype.kind in (\\\"i\\\",\\\"u\\\",\\\"f\\\"):\\n # It's a numeric type\\n if dtype == np.int32:\\n return \\\"integer\\\"\\n elif dtype == np.int64:\\n return \\\"bigint\\\"\\n elif dtype == np.float32:\\n return \\\"real\\\"\\n elif dtype == np.float64:\\n return \\\"float\\\"\\n else:\\n raise ValueError(\\\"Unsupported data type \\\"+str(dtype))\\n elif dtype.kind == \\\"S\\\":\\n # It's a string\\n # Note: this assumes 1 byte = 1 character!\\n return (\\\"char(%d)\\\" % dtype.itemsize)\\n else:\\n # Not numeric or string, don't know what to do with this!\\n raise ValueError(\\\"Unsupported data type \\\"+str(dtype))\",\n \"def _ndarray_dtype(fields):\\n return [\\n (np.str_(key), values)\\n for key, values in fields\\n ]\",\n \"def get_data_types(data):\\n\\tdtypes = data.dtypes\\n\\treturn OrderedDict(zip(dtypes.index, dtypes.astype(str)))\",\n \"def _numpy_datatype_from_nd4j_context():\\n nd4j_datatype = data_type()\\n if nd4j_datatype == 'double':\\n return np.float64\\n elif nd4j_datatype == 'float':\\n return np.float32\\n elif nd4j_datatype == 'half':\\n return np.float16\",\n \"def cudf_dtype_from_pa_type(typ):\\n if pa.types.is_list(typ):\\n return cudf.core.dtypes.ListDtype.from_arrow(typ)\\n elif pa.types.is_struct(typ):\\n return cudf.core.dtypes.StructDtype.from_arrow(typ)\\n elif pa.types.is_decimal(typ):\\n return cudf.core.dtypes.Decimal128Dtype.from_arrow(typ)\\n else:\\n return cudf.api.types.pandas_dtype(typ.to_pandas_dtype())\",\n \"def convert_data_types(fields, src_db='mysql', dest_db='postgres'):\\n\\n data_type_map = {\\n 'mysql': {\\n 'postgres': {\\n 'date': 'date',\\n 'tinyint': 'smallint',\\n 'smallint': 'smallint',\\n 'mediumint': 'integer',\\n 'int': 'bigint',\\n 'bigint': 'numeric',\\n 'float': 'real',\\n 'double': 'double precision',\\n 'tinytext': 'varchar',\\n 'mediumtext': 'varchar',\\n 'longtext': 'varchar',\\n 'varchar': 'varchar',\\n 'text': 'varchar',\\n 'char': 'char',\\n 'binary': 'bytea',\\n 'varbinary': 'bytea',\\n 'tinyblob': 'bytea',\\n 'blob': 'bytea',\\n 'mediumblob': 'bytea',\\n 'longblob': 'bytea',\\n 'datetime': 'timestamp',\\n 'time': 'time',\\n 'decimal': 'decimal',\\n 'json': 'jsonb'\\n }\\n }\\n }\\n\\n for elem in fields:\\n elem['data_type'] = data_type_map[src_db][dest_db][elem['data_type']]\\n\\n if elem['data_type'] == 'decimal':\\n elem['data_type'] += f'''{int(elem['numeric_precision']), int(elem['numeric_scale'])}'''\\n\\n fields = {e['column_name']: e['data_type'] for e in fields}\\n\\n return fields\",\n \"def numpy_type(sqltype):\\n m = re.match(\\\"char\\\\(([0-9]+)\\\\)\\\", sqltype.strip())\\n if m is not None:\\n # It's a string\\n return np.dtype(\\\"|S\\\"+m.group(1))\\n else:\\n # It's a numeric type\\n if sqltype == \\\"integer\\\" or sqltype == \\\"int\\\":\\n return np.int32\\n elif sqltype == \\\"bigint\\\":\\n return np.int64\\n elif sqltype == \\\"real\\\":\\n return np.float32\\n elif sqltype == \\\"float\\\":\\n return np.float64\\n else:\\n raise ValueError(\\\"Unsupported data type \\\"+sqltype)\",\n \"def pandas_typecast(self) -> dict:\\n res = {}\\n for feat in self.data_features:\\n res[feat.key] = ApiForm.typecast(feat.dtype)\\n return res\",\n \"def _assert_dtype(images):\\n dtype = dtypes.as_dtype(images.dtype).base_dtype\\n if dtype not in (dtypes.uint8, dtypes.float32):\\n raise TypeError('Invalid image dtype {0}, expected uint8 or float32'.format(dtype))\\n\\n return dtype\",\n \"def test_base180__dtype(base180, dtype):\\n lons, expected = base180\\n result = wrap(lons, dtype=dtype)\\n if dtype is None:\\n dtype = DTYPE\\n np.testing.assert_array_equal(result, expected.astype(dtype))\",\n \"def load_numpy_core_numerictypes(finder, module):\\n module.AddGlobalName(\\\"bool_\\\")\\n module.AddGlobalName(\\\"cdouble\\\")\\n module.AddGlobalName(\\\"complexfloating\\\")\\n module.AddGlobalName(\\\"csingle\\\")\\n module.AddGlobalName(\\\"double\\\")\\n module.AddGlobalName(\\\"float64\\\")\\n module.AddGlobalName(\\\"float_\\\")\\n module.AddGlobalName(\\\"inexact\\\")\\n module.AddGlobalName(\\\"intc\\\")\\n module.AddGlobalName(\\\"int32\\\")\\n module.AddGlobalName(\\\"number\\\")\\n module.AddGlobalName(\\\"single\\\")\",\n \"def get_scalar_type(dtype):\\r\\n if dtype not in get_scalar_type.cache:\\r\\n get_scalar_type.cache[dtype] = Scalar(dtype=dtype)\\r\\n return get_scalar_type.cache[dtype]\",\n \"def __get_default_dtype(val_type):\\n\\n if val_type == int:\\n dtype = q_consts.int64\\n elif val_type == float:\\n dtype = q_consts.float64\\n else:\\n raise Exception(\\\"input element type %s is not supported\\\" % val_type)\\n return dtype\",\n \"def dtype(self) -> np.dtype:\\n ...\",\n \"def _dtype(self):\\n dref = {\\n \\\"data_mode\\\": object,\\n \\\"latitude\\\": np.float64,\\n \\\"longitude\\\": np.float64,\\n \\\"position_qc\\\": np.int64,\\n \\\"time\\\": object,\\n \\\"time_qc\\\": np.int64,\\n \\\"direction\\\": object,\\n \\\"platform_number\\\": np.int64,\\n \\\"config_mission_number\\\": np.int64,\\n \\\"vertical_sampling_scheme\\\": object,\\n \\\"cycle_number\\\": np.int64,\\n \\\"pres\\\": np.float64,\\n \\\"temp\\\": np.float64,\\n \\\"psal\\\": np.float64,\\n \\\"doxy\\\": np.float64,\\n \\\"pres_qc\\\": np.int64,\\n \\\"temp_qc\\\": object,\\n \\\"psal_qc\\\": object,\\n \\\"doxy_qc\\\": object,\\n \\\"pres_adjusted\\\": np.float64,\\n \\\"temp_adjusted\\\": np.float64,\\n \\\"psal_adjusted\\\": np.float64,\\n \\\"doxy_adjusted\\\": np.float64,\\n \\\"pres_adjusted_qc\\\": object,\\n \\\"temp_adjusted_qc\\\": object,\\n \\\"psal_adjusted_qc\\\": object,\\n \\\"doxy_adjusted_qc\\\": object,\\n \\\"pres_adjusted_error\\\": np.float64,\\n \\\"temp_adjusted_error\\\": np.float64,\\n \\\"psal_adjusted_error\\\": np.float64,\\n \\\"doxy_adjusted_error\\\": np.float64,\\n \\\"ptmp\\\": np.float64,\\n }\\n plist = self._minimal_vlist\\n response = {}\\n for p in plist:\\n response[p] = dref[p]\\n return response\",\n \"def as_correct_dtype(obj: ndarray, required_dtype: dtype) -> ndarray:\\n if obj.dtype != required_dtype:\\n return obj.astype(required_dtype)\\n return obj\",\n \"def _maybe_convert_to_default_type(dtype):\\n if cudf.get_option(\\\"default_integer_bitwidth\\\"):\\n if cudf.api.types.is_signed_integer_dtype(dtype):\\n return cudf.dtype(\\n f'i{cudf.get_option(\\\"default_integer_bitwidth\\\")//8}'\\n )\\n elif cudf.api.types.is_unsigned_integer_dtype(dtype):\\n return cudf.dtype(\\n f'u{cudf.get_option(\\\"default_integer_bitwidth\\\")//8}'\\n )\\n if cudf.get_option(\\n \\\"default_float_bitwidth\\\"\\n ) and cudf.api.types.is_float_dtype(dtype):\\n return cudf.dtype(f'f{cudf.get_option(\\\"default_float_bitwidth\\\")//8}')\\n\\n return dtype\",\n \"def get_data_type(self, idx):\\n return(self.data[idx].dtype)\",\n \"def dtype(self) -> tf.dtypes.DType:\",\n \"def _determine_dtype(fields):\\n # Check whether the required fields are there\\n for field in _NRRD_REQUIRED_FIELDS:\\n if field not in fields:\\n raise NrrdError('Nrrd header misses required field: \\\"%s\\\".' % (field))\\n\\n # Process the data type\\n np_typestring = _TYPEMAP_NRRD2NUMPY[fields['type']]\\n # Endianness is not necessary for ASCII encoding type\\n if np.dtype(np_typestring).itemsize > 1 and fields['encoding'] not in ['ascii', 'text', 'txt']:\\n if 'endian' not in fields:\\n raise NrrdError('Nrrd header misses required field: \\\"endian\\\".')\\n if fields['endian'] == 'big':\\n np_typestring = '>' + np_typestring\\n elif fields['endian'] == 'little':\\n np_typestring = '<' + np_typestring\\n\\n return np.dtype(np_typestring)\",\n \"def _cast_dtype(tik_instance, dst, src, cast_repeat_time,\\n cast_remainder, cast_case):\\n if cast_case == \\\"int8_2_float16\\\":\\n tik_instance.vconv(MAX_MASK, 'none', dst, src, cast_repeat_time,\\n 1, 1, 8, 4, None)\\n with tik_instance.if_scope(cast_remainder != 0):\\n tik_instance.vconv(cast_remainder, 'none',\\n dst[cast_repeat_time * MAX_MASK],\\n src[cast_repeat_time * MAX_MASK],\\n 1, 1, 1, 8, 4, None)\\n elif cast_case == \\\"float16_2_int8\\\":\\n tik_instance.vconv(MAX_MASK, 'none', dst, src, cast_repeat_time,\\n 1, 1, 4, 8, None)\\n with tik_instance.if_scope(cast_remainder != 0):\\n tik_instance.vconv(cast_remainder, 'none',\\n dst[cast_repeat_time * MAX_MASK],\\n src[cast_repeat_time * MAX_MASK],\\n 1, 1, 1, 4, 8, None)\",\n \"def cast(x, dtype):\\r\\n if dtype == 'floatX':\\r\\n dtype = config.floatX\\r\\n\\r\\n _x = as_scalar(x)\\r\\n if _x.type.dtype == dtype:\\r\\n return _x\\r\\n if _x.type.dtype.startswith('complex') and not dtype.startswith('complex'):\\r\\n raise TypeError('Casting from complex to real is ambiguous: consider'\\r\\n ' real(), imag(), angle() or abs()')\\r\\n return _cast_mapping[dtype](_x)\",\n \"def type(self):\\n # type: () -> type\\n return _python_type_map[str(self.xnd_dtype.hidden_dtype)]\",\n \"def _infer_dtype(val):\\n if re.match(r'\\\\d{4}-\\\\d{2}(?:-\\\\d{2})?', val):\\n return 'date'\\n elif re.match(r'[+-]?\\\\d+$', val):\\n return 'int'\\n elif re.match(r'[+-]?\\\\d+%$', val):\\n return 'pct'\\n elif re.match(r'[a-zA-Z ]+', val):\\n return 'text'\\n else:\\n msg = \\\"val={0} dtype not recognized\\\".format(val)\\n raise ValueError(msg)\",\n \"def cudf_dtype_to_pa_type(dtype):\\n if cudf.api.types.is_categorical_dtype(dtype):\\n raise NotImplementedError()\\n elif (\\n cudf.api.types.is_list_dtype(dtype)\\n or cudf.api.types.is_struct_dtype(dtype)\\n or cudf.api.types.is_decimal_dtype(dtype)\\n ):\\n return dtype.to_arrow()\\n else:\\n return np_to_pa_dtype(cudf.dtype(dtype))\",\n \"def dtype(self) -> np.dtype[np.void]:\\n return np.dtype(list(self.items()))\",\n \"def maybe_convert_dtype(data, copy: bool, tz: tzinfo | None = None):\\n if not hasattr(data, \\\"dtype\\\"):\\n # e.g. collections.deque\\n return data, copy\\n\\n if is_float_dtype(data.dtype):\\n # pre-2.0 we treated these as wall-times, inconsistent with ints\\n # GH#23675, GH#45573 deprecated to treat symmetrically with integer dtypes.\\n # Note: data.astype(np.int64) fails ARM tests, see\\n # https://github.com/pandas-dev/pandas/issues/49468.\\n data = data.astype(DT64NS_DTYPE).view(\\\"i8\\\")\\n copy = False\\n\\n elif lib.is_np_dtype(data.dtype, \\\"m\\\") or is_bool_dtype(data.dtype):\\n # GH#29794 enforcing deprecation introduced in GH#23539\\n raise TypeError(f\\\"dtype {data.dtype} cannot be converted to datetime64[ns]\\\")\\n elif isinstance(data.dtype, PeriodDtype):\\n # Note: without explicitly raising here, PeriodIndex\\n # test_setops.test_join_does_not_recur fails\\n raise TypeError(\\n \\\"Passing PeriodDtype data is invalid. Use `data.to_timestamp()` instead\\\"\\n )\\n\\n elif isinstance(data.dtype, ExtensionDtype) and not isinstance(\\n data.dtype, DatetimeTZDtype\\n ):\\n # TODO: We have no tests for these\\n data = np.array(data, dtype=np.object_)\\n copy = False\\n\\n return data, copy\",\n \"def _nd4j_datatype_from_np_array(array):\\n return _nd4j_datatype_from_np(array.dtype.name)\",\n \"def tensor_dtype_to_field(tensor_dtype: int) -> str:\\n return mapping._STORAGE_TENSOR_TYPE_TO_FIELD[ # pylint: disable=protected-access\\n mapping.TENSOR_TYPE_MAP[tensor_dtype].storage_dtype\\n ]\",\n \"def common_type(*arrays):\\n dtypes = {array.dtype.name for array in arrays}\\n has_complex = not _COMPLEX_DTYPES.isdisjoint(dtypes)\\n has_double = not _DOUBLE_DTYPES.isdisjoint(dtypes)\\n return _DTYPE_MAP[has_complex, has_double]\",\n \"def test_dtype_equality(self):\\r\\n dtypes = get_numeric_types(with_complex=True)\\r\\n # Perform all pairwise comparisons of dtypes, making sure comparing\\r\\n # their string representation yields the same result.\\r\\n for dtype1_idx, dtype1 in enumerate(dtypes):\\r\\n for dtype2 in dtypes[dtype1_idx + 1:]:\\r\\n assert (dtype1 == dtype2) == (str(dtype1) == str(dtype2))\",\n \"def minimal_dtype(val: int):\\n if val < 250:\\n return np.uint8\\n return np.uint16 if val < 2**16 - 5 else np.uint32\",\n \"def datatype_conversion(self):\\n\\n category_cols = self.FEATURE_TYPES[\\\"category_cols\\\"]\\n integer_cols = self.FEATURE_TYPES[\\\"integer_cols\\\"]\\n float_cols = self.FEATURE_TYPES[\\\"float_cols\\\"]\\n datetime_cols = self.FEATURE_TYPES[\\\"datetime_cols\\\"]\\n string_cols = self.FEATURE_TYPES[\\\"string_cols\\\"]\\n bool_cols = self.FEATURE_TYPES[\\\"bool_cols\\\"]\\n data = self.data\\n \\n data[category_cols] = data[category_cols].astype('category',copy=False) \\n data[integer_cols] = data[integer_cols].astype('int64',copy=False)\\n data[float_cols] = data[float_cols].astype('float64',copy=False)\\n data[datetime_cols] = data[datetime_cols].astype('datetime64[ns]',copy=False)\\n data[string_cols] = data[string_cols].astype('str',copy=False)\\n data[bool_cols] = data[bool_cols].astype('bool', copy=False)\\n\\n return data\",\n \"def dtype_type( dtype, name = None ):\\n if name:\\n for property in dtype.descr:\\n if property[ 0 ] == name:\\n return property[ 1 ]\\n raise ValueError( \\\"Property not found\\\" )\\n else:\\n if len( dtype.descr ) > 1:\\n raise ValueError( \\\"Multiple types present\\\" )\\n\\n return dtype.descr[ 0 ][ 1 ]\",\n \"def dtype(self):\\n return self._dtype\",\n \"def test_array_dtype(self):\\n dt1 = np.dtype('f4', (2,))\\n dt2 = np.dtype('f4', [2])\\n dt3 = np.dtype('f4', 2)\\n dt4 = np.dtype('f4', 2.1)\\n ht1 = h5t.py_create(dt1)\\n ht2 = h5t.py_create(dt2)\\n ht3 = h5t.py_create(dt3)\\n ht4 = h5t.py_create(dt4)\\n self.assertEqual(ht1.dtype, dt1)\\n self.assertEqual(ht2.dtype, dt1)\\n self.assertEqual(ht3.dtype, dt1)\\n self.assertEqual(ht4.dtype, dt1)\",\n \"def cast_if_floating_dtype(x, dtype=None):\\n return nest.map_structure(functools.partial(cast_single_tensor, dtype=dtype),\\n x)\",\n \"async def get_dtype(self):\\r\\n pass\",\n \"def from_dict(dtype, data):\\n try:\\n field_map = {field.name: field.type for field in fields(dtype)}\\n return dtype(**{key: from_dict(field_map[key], val) for key, val in data.items()})\\n except:\\n return data\",\n \"def __set_utils_types(self):\\n self.__arrayt = type(self.c_byte * 1)\\n # self.__cfuncptrt = type(type(self.memmove))\\n # class _p(self.Structure):\\n # pass\\n # self.__ptrt = type(self.POINTER(_p))\\n self.__basic_types_name = {\\n 'c_bool': '?',\\n 'c_char': 'c',\\n 'c_byte': 'b',\\n 'c_ubyte': 'B',\\n 'c_short': 'h',\\n 'c_ushort': 'H',\\n 'c_int': 'i', # c_int is c_long\\n 'c_uint': 'I',\\n 'int': 'i',\\n 'c_longlong': 'q',\\n 'c_ulonglong': 'Q',\\n 'c_float': 'f',\\n 'c_double': 'd',\\n 'c_longdouble': 'g',\\n 'c_char_p': 's',\\n 'c_void_p': 'P',\\n # 'c_void': 'P', ## void in array is void_p ##DEBUG\\n }\\n if self.__longsize == 4:\\n # long == int\\n self.__basic_types_name.update({'c_long': 'i',\\n 'c_ulong': 'I',\\n 'long': 'i',\\n 'c_void': 'I'})\\n elif self.__longsize == 8:\\n # long == longlong\\n self.__basic_types_name.update({'c_long': 'q',\\n 'c_ulong': 'Q',\\n 'long': 'q',\\n 'c_void': 'Q'})\\n # we need to account for the possible changes in c_longdouble\\n self.__basic_types = set([getattr(self, k) for k in self.__basic_types_name.keys() if hasattr(self, k)])\\n return\",\n \"def NumPyDataType(self):\\n datatype = self.DataType\\n if datatype == gdalconst.GDT_Byte:\\n pixeltype = self.GetMetadataItem('PIXELTYPE', 'IMAGE_STRUCTURE')\\n if pixeltype == 'SIGNEDBYTE':\\n return numpy.int8\\n return numpy.uint8\\n elif datatype == gdalconst.GDT_UInt16:\\n return numpy.uint16\\n elif datatype == gdalconst.GDT_UInt32:\\n return numpy.uint32\\n elif datatype == gdalconst.GDT_Int16:\\n return numpy.int16\\n elif datatype == gdalconst.GDT_Int32:\\n return numpy.int32\\n elif datatype == gdalconst.GDT_Float32:\\n return numpy.float32\\n elif datatype == gdalconst.GDT_Float64:\\n return numpy.float64\\n else:\\n raise ValueError(\\n \\\"Cannot handle DataType: {0}\\\".format(\\n gdal.GetDataTypeName(datatype)\\n )\\n )\",\n \"def np_dtype_to_tensor_dtype(np_dtype: np.dtype) -> int:\\n return cast(\\n int,\\n mapping._NP_TYPE_TO_TENSOR_TYPE[np_dtype], # pylint: disable=protected-access\\n )\",\n \"def map_latencydata_types(type_name):\\n\\n if type_name in ['0', '1']:\\n return Unknown(type_name)\\n\\n # cl is register that is used for certain instructions\\n if type_name == 'cl':\\n return Register(type_name)\\n\\n # TODO make this its own type?\\n if type_name == \\\"stack pointer\\\":\\n return Register(type_name)\\n\\n if type_name == \\\"[r+s*x]\\\" or type_name == \\\"[r+s*y]\\\":\\n return Unknown(type_name)\\n\\n if type_name[:1] == 'r':\\n if type_name[-1] == 'l' or type_name[-1] == 'h':\\n # h, l refer to high, low? get rid of these and continnue as normally\\n type_name = type_name[:-1] # mistake in the document? get rid of the trailing l?\\n size = int(type_name[1:]) if len(type_name) > 1 else None\\n return Register(type_name, size)\\n\\n # vector registers (I think)\\n if type_name in [\\\"xmm\\\", \\\"mmx\\\", \\\"ymm\\\", \\\"mmy\\\"]:\\n return Register(type_name)\\n\\n if type_name == 'i':\\n return Immediate(type_name)\\n if type_name == \\\"v\\\":\\n return Register(type_name)\\n\\n if type_name[:3] == \\\"xmm\\\":\\n return Register(type_name)\\n\\n if type_name[:2] == 'mm':\\n size = int(type_name[2:]) if len(type_name) > 2 else None\\n return Memory(type_name, size)\\n\\n if type_name[0] == 'm':\\n size = int(type_name[1:]) if len(type_name) > 1 else None\\n return Memory(type_name, size)\\n\\n if type_name == \\\"x\\\":\\n return Register(type_name)\\n\\n if type_name == \\\"y\\\":\\n return Register(type_name)\\n\\n if type_name == \\\"near\\\" or type_name == \\\"short\\\":\\n return Unknown(type_name)\\n raise ValueError(f\\\"uknown type {type_name}\\\")\",\n \"def castData(data, type='int64'):\\n data = data.astype(type)\\n return data\",\n \"def xsd_type(dtype):\\n return XSD_TYPE_MAP.get(dtype,'string')\",\n \"def create_data_types(self):\\n for col in self.all_columns:\\n try:\\n if float(self.train[col].iloc[-3]):\\n self.train[col] = self.train[col].astype(np.float32)\\n except:\\n pass\\n self.d_types = self.train.dtypes\",\n \"def type(self):\\n return _python_type_map[self.arrow_dtype.id]\",\n \"def test_base0__dtype(base0, dtype):\\n lons, expected = base0\\n result = wrap(lons, base=0, dtype=dtype)\\n if dtype is None:\\n dtype = DTYPE\\n np.testing.assert_array_equal(result, expected.astype(dtype))\",\n \"def transform_schema(pgschema):\\n datatypes = {}\\n for field in pgschema:\\n if 'cartodb_id' in field:\\n continue\\n datatypes[field] = map_dtypes(pgschema[field]['type'])\\n return datatypes\",\n \"def get_dtype(path,nrows=10):\\n if nrows is not None:\\n train = pd.read_csv(path,nrows=nrows)\\n else:\\n train = pd.read_pickle(path.replace('.csv','.pkl'))\\n col2dtype = OrderedDict()\\n for col in train.columns:\\n if train[col].dtype=='O':\\n col2dtype[col] = 'str'\\n elif train[col].dtype==np.int64:\\n col2dtype[col] = 'int32'\\n else:\\n col2dtype[col] = 'float32'\\n return col2dtype\",\n \"def get_dtype(col):\\n dtype = col.dtype\\n\\n if isinstance(dtype, CategoricalDtype):\\n col = col.astype(type(col.values[0]))\\n out = get_dtype(col)\\n elif np.issubdtype(dtype, np.floating):\\n out = 'float32'\\n elif np.issubdtype(dtype, np.integer):\\n if col.max() < 32767:\\n out = 'int16'\\n else:\\n out = 'int32'\\n elif np.issubdtype(dtype, np.object_):\\n size = int(col.astype(str).str.len().max())\\n out = 'S{:}'.format(size)\\n else:\\n out = dtype\\n\\n return out\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80567575","0.7175208","0.7003725","0.6944843","0.69013226","0.6860262","0.683389","0.68223584","0.6821523","0.68193454","0.6785528","0.6780237","0.6765619","0.67386276","0.6680076","0.66334206","0.6630267","0.6590078","0.65894043","0.65669954","0.65341544","0.6526294","0.6487985","0.6476034","0.64592","0.64228","0.6388282","0.63840926","0.6356783","0.63293165","0.6299242","0.6261024","0.62490827","0.62415373","0.6216397","0.6153166","0.6105888","0.60993767","0.609114","0.608788","0.60839635","0.60023475","0.59985155","0.5994729","0.59919924","0.597974","0.59732485","0.5953545","0.5937404","0.5936363","0.59339124","0.5933889","0.5927363","0.5917535","0.5916951","0.5915099","0.59113544","0.58931863","0.5884982","0.5860438","0.5853827","0.58508056","0.5850671","0.58501285","0.58458966","0.58112705","0.58109736","0.58092093","0.58000475","0.57927054","0.5788867","0.57763016","0.5761252","0.5738144","0.5737698","0.5735927","0.5730243","0.5720769","0.57026505","0.5697303","0.5682402","0.5680572","0.56778437","0.56749606","0.56745833","0.5672146","0.5656518","0.56549746","0.5643514","0.56406415","0.56183434","0.5616889","0.56161755","0.5614356","0.5612349","0.5611922","0.56095964","0.56011784","0.56001174","0.5592893"],"string":"[\n \"0.80567575\",\n \"0.7175208\",\n \"0.7003725\",\n \"0.6944843\",\n \"0.69013226\",\n \"0.6860262\",\n \"0.683389\",\n \"0.68223584\",\n \"0.6821523\",\n \"0.68193454\",\n \"0.6785528\",\n \"0.6780237\",\n \"0.6765619\",\n \"0.67386276\",\n \"0.6680076\",\n \"0.66334206\",\n \"0.6630267\",\n \"0.6590078\",\n \"0.65894043\",\n \"0.65669954\",\n \"0.65341544\",\n \"0.6526294\",\n \"0.6487985\",\n \"0.6476034\",\n \"0.64592\",\n \"0.64228\",\n \"0.6388282\",\n \"0.63840926\",\n \"0.6356783\",\n \"0.63293165\",\n \"0.6299242\",\n \"0.6261024\",\n \"0.62490827\",\n \"0.62415373\",\n \"0.6216397\",\n \"0.6153166\",\n \"0.6105888\",\n \"0.60993767\",\n \"0.609114\",\n \"0.608788\",\n \"0.60839635\",\n \"0.60023475\",\n \"0.59985155\",\n \"0.5994729\",\n \"0.59919924\",\n \"0.597974\",\n \"0.59732485\",\n \"0.5953545\",\n \"0.5937404\",\n \"0.5936363\",\n \"0.59339124\",\n \"0.5933889\",\n \"0.5927363\",\n \"0.5917535\",\n \"0.5916951\",\n \"0.5915099\",\n \"0.59113544\",\n \"0.58931863\",\n \"0.5884982\",\n \"0.5860438\",\n \"0.5853827\",\n \"0.58508056\",\n \"0.5850671\",\n \"0.58501285\",\n \"0.58458966\",\n \"0.58112705\",\n \"0.58109736\",\n \"0.58092093\",\n \"0.58000475\",\n \"0.57927054\",\n \"0.5788867\",\n \"0.57763016\",\n \"0.5761252\",\n \"0.5738144\",\n \"0.5737698\",\n \"0.5735927\",\n \"0.5730243\",\n \"0.5720769\",\n \"0.57026505\",\n \"0.5697303\",\n \"0.5682402\",\n \"0.5680572\",\n \"0.56778437\",\n \"0.56749606\",\n \"0.56745833\",\n \"0.5672146\",\n \"0.5656518\",\n \"0.56549746\",\n \"0.5643514\",\n \"0.56406415\",\n \"0.56183434\",\n \"0.5616889\",\n \"0.56161755\",\n \"0.5614356\",\n \"0.5612349\",\n \"0.5611922\",\n \"0.56095964\",\n \"0.56011784\",\n \"0.56001174\",\n \"0.5592893\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8565042"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":87187,"cells":{"query":{"kind":"string","value":"Desenha o labirinto representado no modelo model."},"document":{"kind":"string","value":"def draw(self, state):\n if state is None:\n state = self.model.current_state\n for row in range(len(self.model.maze.walls)):\n self.__draw_row_division()\n print(\" {0:2d} \".format(row), end='') # Imprime número da linha\n\n for col in range(len(self.model.maze.walls[0])):\n if self.model.maze.walls[row][col] == 1:\n print(\"|XXX\", end='') # Desenha parede\n elif self.model.goal_state.get_element(Coordinate(row, col)):\n if state.player.row == row and state.player.col == col:\n print(\"|G-P\", end='') # Desenha objetivo e jogador.\n elif state.get_element(Coordinate(row, col)):\n print(\"|G-B\", end='') # Desenha objetivo e caixa.\n else:\n print(\"| G\", end='') # Desenha objetivo\n elif state.player.row == row and state.player.col == col:\n print(\"| P\", end='') # Desenha jogador\n elif state.get_element(Coordinate(row, col)):\n print(\"| B\", end='') # Desenha caixa.\n else:\n print(\"| \", end='') # Desenha vazio\n print(\"|\")\n if row == (len(self.model.maze.walls) - 1):\n self.__draw_row_division()"},"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 model(self):","def model(self):","def model(self):","def model(self):","def model(self):","def __init__(self):\n self.model = None","def __init__(self):\n self.model = None","def create_model(self):\n self.model = None\n pass","def save_model(self, request, obj, form, change):\n obj.revise()","def MakeModel(self):\n pass","def reset_model(self):\n raise NotImplementedError","def reset_model(self):\n raise NotImplementedError","def reset_model(self):\n raise NotImplementedError","def __init__(self, datastoreio_stub, label=None):\n super(DeleteModels, self).__init__(label=label)\n self.datastoreio = datastoreio_stub","def LoadModel(self):\n\t\tself.form = loader.loadModel(\"models/lampExport\")\n\t\t#self.form.setScale(.007)\n\t\tself.form.reparentTo(render)\n\t\tself.form.setPos(self.xpos, self.ypos, -30)","def get_model():\n return UNISAL","def test_issue_remove_label(self):\n pass","def __str__(self):\r\n return self.afficherOBJ()","def __repr__(self):\n return f'ResidenciaModel(name={self.neighbourhood_group}, neighbourhood={self.room_type})'","def create_model(self):\n pass","def create_model(self):\n pass","def save_model(self):\n pass","def __init__(self, model):\n\t\tself.model = model","def loadModel(self):\n#FLAG: still waiting on boost image\n\t\tself.form = loader.loadModel(\"models/panda-model\")\n\t\tself.form.setScape(.005)\n\t\tself.form.reparentTo(render)","def __init__(self, model):\n self.model = model","def __init__(self, model):\n self.model = model","def __init__(self, model):\n self.model = model","def __init__(self, model):\n self.model = model","def dummy():\n\t\t\tself.save()","def model(self) -> str:\n ...","def convert_to_model(self, *args):","def __init__(self):\n self.modelo = [\"A\", \"sucio\", \"sucio\",\"sucio\", \"sucio\",\"sucio\", \"sucio\"]","def save_model( self, request, obj, form, change ):\n obj.save()","def save_model(self, request, obj, form, change):\n Flag.objects.filter(question=obj).delete()","def __init__(self, model):\n if model == \"biblis\" :\n data = [1.3200e+00, 2.7720e-01, 2.6562e-03, \\\n 7.1596e-02, 0.00000000, 0.00000000, \\\n 2.3106e-02] \n else :\n raise Exception(\"Reflector model not available\")\n self.model = model\n # Default group data.\n self.D1 = data[0]\n self.D2 = data[1]\n self.A1 = data[2]\n self.A2 = data[3] \n self.F1 = data[4]\n self.F2 = data[5] \n self.S12 = data[6] \n self.R1 = self.A1 + self.S12","def clean(self):\r\n self.roadrunnerModel = None\r\n return self","def instance_to_model(self):\n pass","def remove(self, label):\n\n\t\t\tself[label].remove()","def labelTable(self,table):\n \n for sslice,_, lFields in self._lLabellingInstruction:\n for field in lFields:\n if field is not None:\n try:\n for cell in np.nditer(table.getNPArray()[sslice],['refs_ok'],op_dtypes=np.dtype(object)):\n cell[()].addField(field.cloneMe())\n except: pass","def limpiarVentana(self):\n self.limpiarTabla(self.tableFactura)\n self.lineNumero.setEnabled(True)\n self.lineNumero.clear()\n self.limpiarTabla(self.tableNC)","def __str__(self):\n return f\"model {self._name}\"","def usar(self,letra):\n self.atril.remove(letra)","def cleanTable(self):\n self.currentGroup = None","def SetModel( self, loader ):\n self.loader = loader\n self.adapter,tree,rows = self.RootNode( )\n self.listControl.integrateRecords( rows.values())\n self.activated_node = tree\n self.squareMap.SetModel( tree, self.adapter )\n self.RecordHistory()","def __init__(self, model: object):\n self.model = model","def __init__(self, model):\n self._model = model","def __delattr__(self, attr):\n # Set to default value\n if attr in self.fields:\n setattr(self, attr, self.fields[attr].default)\n else:\n super(BaseModel, self).__delattr__(attr)","def __init__(self):\n Model.__init__(self)\n self.rellenar_lista()","def __init__(self, *args, **kwargs):\n\n # Les lignes suivantes permettent de modifier les label d'un champ dans la page\n super(ModelForm, self).__init__(*args, **kwargs)\n self.fields[\"nom_de_l_evenement\"].label = \"Nom de l'évènement\"\n self.fields[\"date_de_l_evenement\"].label = \"Date de l'évènement\" # utiliser plutôt l'attribut label comme pour AbonnementEvenementForm\n self.fields[\"fichier\"].label = \"Photo(s)\"","def add_model(self, label):\n s = label.replace(' ', '_')\n if s not in self.models:\n self.models.append(s)","def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n\n for field in self.fields:\n self.fields[field].label = False","def labelUnknown(self):\n self.satisfiability = Satisfiability.UNKNOWN\n self.model = None\n self.unsatCore = []","def delete_model(self, request, obj):\n obj.post.comNumDrease()\n obj.delete()","def dump_model(self):","def updateModel(self):\n pass","def __str__(self):\n return '%s%s' % (self.name, ' - %s' % self.model if self.model else '')","def __init__(self, model: Model1D):\n super().__init__(model=model)","def __init__(self, model: Model1D):\n super().__init__(model=model)","def __init__(self, model: Model1D):\n super().__init__(model=model)","def __init__(self, model: Model1D):\n super().__init__(model=model)","def __init__(self, model: Model1D):\n super().__init__(model=model)","def remove_model(self, model):\n assert isinstance(model, Model)\n\n self.model_list.remove(model)\n del self.model_dict[model.model_id]\n model.structure = None\n\n ## if the default model is being removed, choose a new default model\n ## if possible\n if model == self.default_model:\n if len(self.model_list) > 0:\n self.default_model = self.model_list[0]\n else:\n self.default_model = None","def model(self):\n self.add_file_string('Model file')\n self.make_dangerous('Model file')","def __unicode__(self):\n return self.nombre","def __unicode__(self):\n return self.nombre","def __init__(self):\n self.name = \"Kursawe\"\n objectives = [o_ku_1, o_ku_2]\n decisions = [Decision(-5, 5), Decision(-5, 5), Decision(-5, 5)]\n Model.__init__(self, objectives, None, decisions)","def remove_label(self, ):\n if self.AttributeNames.LABEL in self.attrs:\n del self.attrs[self.AttributeNames.LABEL]\n return self","def delete(self, using=None):\n self.model.remove_field(self)","def build_model():","def __unicode__(self):\n return \"Pedido: {} Producto: {}\".format(self.pedido, self.producto)","def print_model(self, model):\n return \"null\"","def lblencoder(self):\n for i in self.data.columns:\n if self.data[i].dtype=='object':\n lbl = preprocessing.LabelEncoder()\n lbl.fit(list(self.data[i].values))\n self.data[i] = lbl.transform(list(self.data[i].values))\n \n self.X = self.data.drop(self.target, axis =1)\n self.y = self.data[self.target]","def setUpFormData(self):\n super(NoLabForUser, self).setUpFormData()\n self.formData['labGroup'] = str(self.labGroup.id)","def update_model(self):\n pass","def save_model(self, request, instance, form, change):\n pass","def reset(self):\n logging.info(\"Resetting DINTModel.\")\n if self.classifier:\n self.server.remove_model(self.classifier)\n # for ds in self.server.datasets:\n # self.server.remove_dataset(ds)\n # TODO: remove datasets?\n self.classifier = None","def nuevo(self, ventana):\n self.objeto = ventana.objeto\n self.set_text(self.objeto.__str__())\n self.id = self.objeto.id\n self.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse(\"#FFFFFF\"))\n ventana.destroy()\n self.busqueda.destroy()","def __init__(self):\n self.name = \"Osyczka\"\n objectives = [ob_os_1, ob_os_2]\n constraints = [con_os_1, con_os_2, con_os_3, con_os_4, con_os_5, con_os_6]\n decisions = [Decision(0, 10), Decision(0, 10), Decision(1, 5), Decision(0, 6), Decision(1, 5), Decision(0, 10)]\n Model.__init__(self, objectives, constraints, decisions)","def reset_btn(self):\n self.dept_id_ent.delete(0, END)\n self.dept_name_ent.delete(0, END)","def unsetId(self):\n return _libsbml.Model_unsetId(self)","def load_model(self):\n pass","def hook(self):\n usr_df = self.new_model()\n print(usr_df)\n mycolumns = {\n 'user_id':'usr_id'\n }\n sort_df = usr_df.rename(columns=mycolumns)\n data = sort_df\n \n return data","def __str__(self):\n return self.modalidades","def test_issue_clear_labels(self):\n pass","def __str__(self):\n return super().__str__() + self.model.__str__()","def __init__(self):\n super(SiLU, self).__init__()","def setModel(self):\n if self.model != \"\":\n # Setup the visual model\n # Animated stuff should be added soon\n print MODEL_DIR\n print self.model\n model = loader.loadModel(MODEL_DIR + self.model)\n model.reparentTo(self.bulletBody)","def __init__(self, model, **kwargs):\n\n super().__init__(model)\n\n self._ut = UnscentedTransform(model, **kwargs)","def __init__(self, inplace=False):\n super(SELU, self).__init__()\n self.inplace = inplace","def model_definition(self):\n pass","def __init__(self, model: Model1D):\n self._model = model","def unset_label(self):\n self.set_label(self.label.prev_str, self.label.prev_color)","def __str__(self):\n return self.nombre","def __str__(self):\n return self.nombre","def __str__(self):\n return self.nombre","def model(self) -> Type[Model]:","def __repr__(self):\n return misc.describe_layer(self, name=\"model\")","def __str__(self):\n return self.idTesouraria","def change_glavniLabel(self, ulaz):\r\n mapa = ulaz['opis']\r\n mjerenjeId = ulaz['mjerenjeId']\r\n datum = ulaz['datum']\r\n postaja = mapa['postajaNaziv']\r\n komponenta = mapa['komponentaNaziv']\r\n formula = mapa['komponentaFormula']\r\n# mjernaJedinica = mapa['komponentaMjernaJedinica']\r\n# opis = '{0}, {1}( {2} ) [{3}]. Datum : {4} . mjerenjeId:{5}'.format(postaja, komponenta, formula, mjernaJedinica, datum, mjerenjeId)\r\n opis = '{0}, {1}( {2} ). Datum : {3} . mjerenjeId:{4}'.format(postaja, komponenta, formula, datum, mjerenjeId)\r\n self.glavniLabel.setText(opis)\r\n logging.info('glavniLabel promjenjen, value = {0}'.format(opis))","def unsetModel(self):\n return _libsbml.L3ParserSettings_unsetModel(self)","def load_model(self) -> Any:"],"string":"[\n \"def model(self):\",\n \"def model(self):\",\n \"def model(self):\",\n \"def model(self):\",\n \"def model(self):\",\n \"def __init__(self):\\n self.model = None\",\n \"def __init__(self):\\n self.model = None\",\n \"def create_model(self):\\n self.model = None\\n pass\",\n \"def save_model(self, request, obj, form, change):\\n obj.revise()\",\n \"def MakeModel(self):\\n pass\",\n \"def reset_model(self):\\n raise NotImplementedError\",\n \"def reset_model(self):\\n raise NotImplementedError\",\n \"def reset_model(self):\\n raise NotImplementedError\",\n \"def __init__(self, datastoreio_stub, label=None):\\n super(DeleteModels, self).__init__(label=label)\\n self.datastoreio = datastoreio_stub\",\n \"def LoadModel(self):\\n\\t\\tself.form = loader.loadModel(\\\"models/lampExport\\\")\\n\\t\\t#self.form.setScale(.007)\\n\\t\\tself.form.reparentTo(render)\\n\\t\\tself.form.setPos(self.xpos, self.ypos, -30)\",\n \"def get_model():\\n return UNISAL\",\n \"def test_issue_remove_label(self):\\n pass\",\n \"def __str__(self):\\r\\n return self.afficherOBJ()\",\n \"def __repr__(self):\\n return f'ResidenciaModel(name={self.neighbourhood_group}, neighbourhood={self.room_type})'\",\n \"def create_model(self):\\n pass\",\n \"def create_model(self):\\n pass\",\n \"def save_model(self):\\n pass\",\n \"def __init__(self, model):\\n\\t\\tself.model = model\",\n \"def loadModel(self):\\n#FLAG: still waiting on boost image\\n\\t\\tself.form = loader.loadModel(\\\"models/panda-model\\\")\\n\\t\\tself.form.setScape(.005)\\n\\t\\tself.form.reparentTo(render)\",\n \"def __init__(self, model):\\n self.model = model\",\n \"def __init__(self, model):\\n self.model = model\",\n \"def __init__(self, model):\\n self.model = model\",\n \"def __init__(self, model):\\n self.model = model\",\n \"def dummy():\\n\\t\\t\\tself.save()\",\n \"def model(self) -> str:\\n ...\",\n \"def convert_to_model(self, *args):\",\n \"def __init__(self):\\n self.modelo = [\\\"A\\\", \\\"sucio\\\", \\\"sucio\\\",\\\"sucio\\\", \\\"sucio\\\",\\\"sucio\\\", \\\"sucio\\\"]\",\n \"def save_model( self, request, obj, form, change ):\\n obj.save()\",\n \"def save_model(self, request, obj, form, change):\\n Flag.objects.filter(question=obj).delete()\",\n \"def __init__(self, model):\\n if model == \\\"biblis\\\" :\\n data = [1.3200e+00, 2.7720e-01, 2.6562e-03, \\\\\\n 7.1596e-02, 0.00000000, 0.00000000, \\\\\\n 2.3106e-02] \\n else :\\n raise Exception(\\\"Reflector model not available\\\")\\n self.model = model\\n # Default group data.\\n self.D1 = data[0]\\n self.D2 = data[1]\\n self.A1 = data[2]\\n self.A2 = data[3] \\n self.F1 = data[4]\\n self.F2 = data[5] \\n self.S12 = data[6] \\n self.R1 = self.A1 + self.S12\",\n \"def clean(self):\\r\\n self.roadrunnerModel = None\\r\\n return self\",\n \"def instance_to_model(self):\\n pass\",\n \"def remove(self, label):\\n\\n\\t\\t\\tself[label].remove()\",\n \"def labelTable(self,table):\\n \\n for sslice,_, lFields in self._lLabellingInstruction:\\n for field in lFields:\\n if field is not None:\\n try:\\n for cell in np.nditer(table.getNPArray()[sslice],['refs_ok'],op_dtypes=np.dtype(object)):\\n cell[()].addField(field.cloneMe())\\n except: pass\",\n \"def limpiarVentana(self):\\n self.limpiarTabla(self.tableFactura)\\n self.lineNumero.setEnabled(True)\\n self.lineNumero.clear()\\n self.limpiarTabla(self.tableNC)\",\n \"def __str__(self):\\n return f\\\"model {self._name}\\\"\",\n \"def usar(self,letra):\\n self.atril.remove(letra)\",\n \"def cleanTable(self):\\n self.currentGroup = None\",\n \"def SetModel( self, loader ):\\n self.loader = loader\\n self.adapter,tree,rows = self.RootNode( )\\n self.listControl.integrateRecords( rows.values())\\n self.activated_node = tree\\n self.squareMap.SetModel( tree, self.adapter )\\n self.RecordHistory()\",\n \"def __init__(self, model: object):\\n self.model = model\",\n \"def __init__(self, model):\\n self._model = model\",\n \"def __delattr__(self, attr):\\n # Set to default value\\n if attr in self.fields:\\n setattr(self, attr, self.fields[attr].default)\\n else:\\n super(BaseModel, self).__delattr__(attr)\",\n \"def __init__(self):\\n Model.__init__(self)\\n self.rellenar_lista()\",\n \"def __init__(self, *args, **kwargs):\\n\\n # Les lignes suivantes permettent de modifier les label d'un champ dans la page\\n super(ModelForm, self).__init__(*args, **kwargs)\\n self.fields[\\\"nom_de_l_evenement\\\"].label = \\\"Nom de l'évènement\\\"\\n self.fields[\\\"date_de_l_evenement\\\"].label = \\\"Date de l'évènement\\\" # utiliser plutôt l'attribut label comme pour AbonnementEvenementForm\\n self.fields[\\\"fichier\\\"].label = \\\"Photo(s)\\\"\",\n \"def add_model(self, label):\\n s = label.replace(' ', '_')\\n if s not in self.models:\\n self.models.append(s)\",\n \"def __init__(self, *args, **kwargs):\\n super().__init__(*args, **kwargs)\\n\\n for field in self.fields:\\n self.fields[field].label = False\",\n \"def labelUnknown(self):\\n self.satisfiability = Satisfiability.UNKNOWN\\n self.model = None\\n self.unsatCore = []\",\n \"def delete_model(self, request, obj):\\n obj.post.comNumDrease()\\n obj.delete()\",\n \"def dump_model(self):\",\n \"def updateModel(self):\\n pass\",\n \"def __str__(self):\\n return '%s%s' % (self.name, ' - %s' % self.model if self.model else '')\",\n \"def __init__(self, model: Model1D):\\n super().__init__(model=model)\",\n \"def __init__(self, model: Model1D):\\n super().__init__(model=model)\",\n \"def __init__(self, model: Model1D):\\n super().__init__(model=model)\",\n \"def __init__(self, model: Model1D):\\n super().__init__(model=model)\",\n \"def __init__(self, model: Model1D):\\n super().__init__(model=model)\",\n \"def remove_model(self, model):\\n assert isinstance(model, Model)\\n\\n self.model_list.remove(model)\\n del self.model_dict[model.model_id]\\n model.structure = None\\n\\n ## if the default model is being removed, choose a new default model\\n ## if possible\\n if model == self.default_model:\\n if len(self.model_list) > 0:\\n self.default_model = self.model_list[0]\\n else:\\n self.default_model = None\",\n \"def model(self):\\n self.add_file_string('Model file')\\n self.make_dangerous('Model file')\",\n \"def __unicode__(self):\\n return self.nombre\",\n \"def __unicode__(self):\\n return self.nombre\",\n \"def __init__(self):\\n self.name = \\\"Kursawe\\\"\\n objectives = [o_ku_1, o_ku_2]\\n decisions = [Decision(-5, 5), Decision(-5, 5), Decision(-5, 5)]\\n Model.__init__(self, objectives, None, decisions)\",\n \"def remove_label(self, ):\\n if self.AttributeNames.LABEL in self.attrs:\\n del self.attrs[self.AttributeNames.LABEL]\\n return self\",\n \"def delete(self, using=None):\\n self.model.remove_field(self)\",\n \"def build_model():\",\n \"def __unicode__(self):\\n return \\\"Pedido: {} Producto: {}\\\".format(self.pedido, self.producto)\",\n \"def print_model(self, model):\\n return \\\"null\\\"\",\n \"def lblencoder(self):\\n for i in self.data.columns:\\n if self.data[i].dtype=='object':\\n lbl = preprocessing.LabelEncoder()\\n lbl.fit(list(self.data[i].values))\\n self.data[i] = lbl.transform(list(self.data[i].values))\\n \\n self.X = self.data.drop(self.target, axis =1)\\n self.y = self.data[self.target]\",\n \"def setUpFormData(self):\\n super(NoLabForUser, self).setUpFormData()\\n self.formData['labGroup'] = str(self.labGroup.id)\",\n \"def update_model(self):\\n pass\",\n \"def save_model(self, request, instance, form, change):\\n pass\",\n \"def reset(self):\\n logging.info(\\\"Resetting DINTModel.\\\")\\n if self.classifier:\\n self.server.remove_model(self.classifier)\\n # for ds in self.server.datasets:\\n # self.server.remove_dataset(ds)\\n # TODO: remove datasets?\\n self.classifier = None\",\n \"def nuevo(self, ventana):\\n self.objeto = ventana.objeto\\n self.set_text(self.objeto.__str__())\\n self.id = self.objeto.id\\n self.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse(\\\"#FFFFFF\\\"))\\n ventana.destroy()\\n self.busqueda.destroy()\",\n \"def __init__(self):\\n self.name = \\\"Osyczka\\\"\\n objectives = [ob_os_1, ob_os_2]\\n constraints = [con_os_1, con_os_2, con_os_3, con_os_4, con_os_5, con_os_6]\\n decisions = [Decision(0, 10), Decision(0, 10), Decision(1, 5), Decision(0, 6), Decision(1, 5), Decision(0, 10)]\\n Model.__init__(self, objectives, constraints, decisions)\",\n \"def reset_btn(self):\\n self.dept_id_ent.delete(0, END)\\n self.dept_name_ent.delete(0, END)\",\n \"def unsetId(self):\\n return _libsbml.Model_unsetId(self)\",\n \"def load_model(self):\\n pass\",\n \"def hook(self):\\n usr_df = self.new_model()\\n print(usr_df)\\n mycolumns = {\\n 'user_id':'usr_id'\\n }\\n sort_df = usr_df.rename(columns=mycolumns)\\n data = sort_df\\n \\n return data\",\n \"def __str__(self):\\n return self.modalidades\",\n \"def test_issue_clear_labels(self):\\n pass\",\n \"def __str__(self):\\n return super().__str__() + self.model.__str__()\",\n \"def __init__(self):\\n super(SiLU, self).__init__()\",\n \"def setModel(self):\\n if self.model != \\\"\\\":\\n # Setup the visual model\\n # Animated stuff should be added soon\\n print MODEL_DIR\\n print self.model\\n model = loader.loadModel(MODEL_DIR + self.model)\\n model.reparentTo(self.bulletBody)\",\n \"def __init__(self, model, **kwargs):\\n\\n super().__init__(model)\\n\\n self._ut = UnscentedTransform(model, **kwargs)\",\n \"def __init__(self, inplace=False):\\n super(SELU, self).__init__()\\n self.inplace = inplace\",\n \"def model_definition(self):\\n pass\",\n \"def __init__(self, model: Model1D):\\n self._model = model\",\n \"def unset_label(self):\\n self.set_label(self.label.prev_str, self.label.prev_color)\",\n \"def __str__(self):\\n return self.nombre\",\n \"def __str__(self):\\n return self.nombre\",\n \"def __str__(self):\\n return self.nombre\",\n \"def model(self) -> Type[Model]:\",\n \"def __repr__(self):\\n return misc.describe_layer(self, name=\\\"model\\\")\",\n \"def __str__(self):\\n return self.idTesouraria\",\n \"def change_glavniLabel(self, ulaz):\\r\\n mapa = ulaz['opis']\\r\\n mjerenjeId = ulaz['mjerenjeId']\\r\\n datum = ulaz['datum']\\r\\n postaja = mapa['postajaNaziv']\\r\\n komponenta = mapa['komponentaNaziv']\\r\\n formula = mapa['komponentaFormula']\\r\\n# mjernaJedinica = mapa['komponentaMjernaJedinica']\\r\\n# opis = '{0}, {1}( {2} ) [{3}]. Datum : {4} . mjerenjeId:{5}'.format(postaja, komponenta, formula, mjernaJedinica, datum, mjerenjeId)\\r\\n opis = '{0}, {1}( {2} ). Datum : {3} . mjerenjeId:{4}'.format(postaja, komponenta, formula, datum, mjerenjeId)\\r\\n self.glavniLabel.setText(opis)\\r\\n logging.info('glavniLabel promjenjen, value = {0}'.format(opis))\",\n \"def unsetModel(self):\\n return _libsbml.L3ParserSettings_unsetModel(self)\",\n \"def load_model(self) -> Any:\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.55984116","0.55984116","0.55984116","0.55984116","0.55984116","0.5581929","0.5581929","0.5559378","0.5522319","0.54893225","0.54143155","0.54143155","0.54143155","0.5379634","0.53113645","0.5260471","0.5246865","0.52457726","0.52361137","0.522273","0.522273","0.5215112","0.5188489","0.5185986","0.51832634","0.51832634","0.51832634","0.51832634","0.516299","0.5155515","0.51393867","0.50986445","0.5096764","0.50872725","0.50705236","0.5069357","0.50601906","0.50510746","0.5049927","0.50439525","0.5038608","0.5025344","0.50169945","0.5012978","0.50101554","0.49980107","0.49800554","0.49773479","0.49679324","0.4956867","0.49426058","0.49301562","0.49197355","0.49157763","0.49141836","0.49117136","0.490566","0.490566","0.490566","0.490566","0.490566","0.4902225","0.48986745","0.48979324","0.48979324","0.48930976","0.48803002","0.48799545","0.48772275","0.4871825","0.48695153","0.48680314","0.48639116","0.48580527","0.48518866","0.4848367","0.4845598","0.48435444","0.48416546","0.48382774","0.4830768","0.48266134","0.48240244","0.48225844","0.4817238","0.48155132","0.48032913","0.48025286","0.47843796","0.47838354","0.47830403","0.478225","0.4780965","0.4780965","0.4780965","0.4780923","0.4780831","0.47799948","0.47766873","0.47736543","0.4767421"],"string":"[\n \"0.55984116\",\n \"0.55984116\",\n \"0.55984116\",\n \"0.55984116\",\n \"0.55984116\",\n \"0.5581929\",\n \"0.5581929\",\n \"0.5559378\",\n \"0.5522319\",\n \"0.54893225\",\n \"0.54143155\",\n \"0.54143155\",\n \"0.54143155\",\n \"0.5379634\",\n \"0.53113645\",\n \"0.5260471\",\n \"0.5246865\",\n \"0.52457726\",\n \"0.52361137\",\n \"0.522273\",\n \"0.522273\",\n \"0.5215112\",\n \"0.5188489\",\n \"0.5185986\",\n \"0.51832634\",\n \"0.51832634\",\n \"0.51832634\",\n \"0.51832634\",\n \"0.516299\",\n \"0.5155515\",\n \"0.51393867\",\n \"0.50986445\",\n \"0.5096764\",\n \"0.50872725\",\n \"0.50705236\",\n \"0.5069357\",\n \"0.50601906\",\n \"0.50510746\",\n \"0.5049927\",\n \"0.50439525\",\n \"0.5038608\",\n \"0.5025344\",\n \"0.50169945\",\n \"0.5012978\",\n \"0.50101554\",\n \"0.49980107\",\n \"0.49800554\",\n \"0.49773479\",\n \"0.49679324\",\n \"0.4956867\",\n \"0.49426058\",\n \"0.49301562\",\n \"0.49197355\",\n \"0.49157763\",\n \"0.49141836\",\n \"0.49117136\",\n \"0.490566\",\n \"0.490566\",\n \"0.490566\",\n \"0.490566\",\n \"0.490566\",\n \"0.4902225\",\n \"0.48986745\",\n \"0.48979324\",\n \"0.48979324\",\n \"0.48930976\",\n \"0.48803002\",\n \"0.48799545\",\n \"0.48772275\",\n \"0.4871825\",\n \"0.48695153\",\n \"0.48680314\",\n \"0.48639116\",\n \"0.48580527\",\n \"0.48518866\",\n \"0.4848367\",\n \"0.4845598\",\n \"0.48435444\",\n \"0.48416546\",\n \"0.48382774\",\n \"0.4830768\",\n \"0.48266134\",\n \"0.48240244\",\n \"0.48225844\",\n \"0.4817238\",\n \"0.48155132\",\n \"0.48032913\",\n \"0.48025286\",\n \"0.47843796\",\n \"0.47838354\",\n \"0.47830403\",\n \"0.478225\",\n \"0.4780965\",\n \"0.4780965\",\n \"0.4780965\",\n \"0.4780923\",\n \"0.4780831\",\n \"0.47799948\",\n \"0.47766873\",\n \"0.47736543\",\n \"0.4767421\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":87188,"cells":{"query":{"kind":"string","value":"Transpose iload and istore. Must be fix in a future version."},"document":{"kind":"string","value":"def fix_iload(self):\n # Fixme : store in a good way and in the right type istore and iload\n for i in range(len(self.iload)):\n self.iload[i] = np.ascontiguousarray(self.iload[i].T, dtype=np.int32)\n self.istore = np.ascontiguousarray(self.istore.T, dtype=np.int32)"},"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 transpose():","def transpose_load_concat(self, **kwargs):\n if self.mask_train:\n datamask=self.add_mask()\n thedatas={}\n for key, value in kwargs.items():\n if not self.mask_train:\n thedatas[key]=value.X_train.transpose('a','x','y','features').values\n if self.mask_train:\n temp=value.X_train.transpose('a','x','y','features').values\n thedatas[key]=np.where(np.repeat(datamask['X_train'].values[...,np.newaxis], 4, axis=3)==0, 0, temp)\n label=value.X_train_label.values\n if len(kwargs) > 1:\n X_train=np.concatenate(list(thedatas.values()), axis=3)\n if len(kwargs)==1:\n X_train=np.squeeze(np.asarray(list(thedatas.values())))\n return X_train, label","def transpose(self) -> None:\n ...","def transpose(self):\n pass","def load_data_wrapper():\n\ttr_d, te_d = load_data()\n\ttraining_inputs = [np.reshape(x, (4, 1)) for x in tr_d[0]]\n\ttraining_results = [vectorized_result(y) for y in tr_d[1]]\n\ttraining_data = zip(training_inputs, training_results)\n\ttest_inputs = [np.reshape(x, (4, 1)) for x in te_d[0]]\n\ttest_data = zip(test_inputs, te_d[1])\n\treturn (training_data, test_data)","def load_data_wrapper():\n tr_d, va_d, te_d = load_data()\n training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]\n training_results = [vectorized_result(y) for y in tr_d[1]]\n training_data = zip(training_inputs, training_results)\n validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]\n validation_data = zip(validation_inputs, va_d[1])\n test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]\n test_data = zip(test_inputs, te_d[1])\n return (training_data, validation_data, test_data)","def load_data_wrapper():\n tr_d, va_d, te_d = load_data()\n training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]\n training_results = [vectorized_result(y) for y in tr_d[1]]\n training_data = zip(training_inputs, training_results)\n validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]\n validation_data = zip(validation_inputs, va_d[1])\n test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]\n test_data = zip(test_inputs, te_d[1])\n return (training_data, validation_data, test_data)","def load_data_wrapper():\n tr_d, va_d, te_d = load_data()\n training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]\n training_results = [vectorized_result(y) for y in tr_d[1]]\n training_data = list(zip(training_inputs, training_results))\n validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]\n validation_data = list(zip(validation_inputs, va_d[1]))\n test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]\n test_data = list(zip(test_inputs, te_d[1]))\n return (training_data, validation_data, test_data)","def irtranspose(x: torch.Tensor, dims):\n _dims = list(dims)\n _ir_dims = [_dims.index(i) for i in range(len(_dims))]\n return transpose(x, _ir_dims)","def set_iload(self):\n k = self.istore[0]\n v = self.stencil.get_all_velocities()\n indices = self.istore[1:] + v[k].T\n self.iload.append(np.concatenate([k[np.newaxis, :], indices]))","def unzip_batch(batch):\n unzip = [[i for i, j in batch],\n [j for i, j in batch]]\n return np.transpose(unzip[0]), np.transpose(unzip[1])","def transpose_chunks(self, order: tuple) -> None:\n for key, array in self.chunks.items():\n self.chunks[key] = array.transpose(order)","def load_data_wrapper():\n\n tr_d, va_d, te_d = load_data()\n\n training_inputs = [np.reshape(a=x, newshape=(784, 1)) for x in tr_d[0]]\n training_results = [vectorized_result(y) for y in tr_d[1]]\n training_data = zip(training_inputs, training_results)\n # Need to do list(zip(...)) instead of just zip(...) in Python 3\n # training_data = list(zip(training_inputs, training_results))\n\n validation_inputs = [np.reshape(a=x, newshape=(784, 1)) for x in va_d[0]]\n validation_data = zip(validation_inputs, va_d[1])\n # validation_data = list(zip(validation_inputs, va_d[1]))\n\n test_inputs = [np.reshape(a=x, newshape=(784, 1)) for x in te_d[0]]\n test_data = zip(test_inputs, te_d[1])\n # test_data = list(zip(test_inputs, te_d[1]))\n\n return training_data, validation_data, test_data","def load_dataset():\n temp = gzip.open('mnist.pkl.gz')\n train, val , test = pickle.load(temp,encoding='latin1')\n temp.close()\n train_inp = [np.reshape(x, (784,1)) for x in train[0]]\n train_outp = [one_hot(y) for y in train[1]]\n training_data = zip(train_inp, train_outp)\n validation_inp = [np.reshape(x, (784, 1)) for x in val[0]]\n validation_data = zip(validation_inp, val[1])\n test_inp = [np.reshape(x, (784, 1)) for x in test[0]]\n test_data = zip(test_inp, test[1])\n return (training_data,validation_data,test_data)","def fortran_storage(a):\n if NumPy_type(a) == 'Numeric' or NumPy_type(a) == 'numarray':\n return transpose(transpose(a).copy())\n else:\n import numpy\n return numpy.asarray(a, fortran=True)","def load_data():\n (trainx, trainy), (valx, valy), (testx, testy) = pickle.load(gzip.open(\"data/mnist_one_hot.pkl.gz\"),\n encoding=\"latin1\")\n trainy = np.argmax(trainy, axis=1)\n valy = np.argmax(valy, axis=1)\n testy = np.argmax(testy, axis=1)\n trainx = trainx * 2 - 1\n valx = valx * 2 - 1\n testx = testx * 2 - 1\n return (trainx.reshape(-1, 1, 28, 28), trainy), (valx.reshape(-1, 1, 28, 28), valy), (testx.reshape(-1, 1, 28, 28),\n testy)","def set_iload(self):\n k = self.istore[0]\n ksym = self.stencil.get_symmetric()[k][np.newaxis, :]\n v = self.stencil.get_all_velocities()\n indices = self.istore[1:] + v[k].T\n self.iload.append(np.concatenate([ksym, indices]))","def transpose(m):\n\n pass","def transpose(self):\n order = list(self.order)\n order[-2], order[-1] = order[-1], order[-2]\n self.order = order","def rearrange_batch(batch):\n return list(zip(*batch))","def unpackRecords(self,unpackTypes):\n for record in self.records:\n if record.name in unpackTypes:\n record.load(unpack=True)","def set_iload(self):\n k = self.istore[0]\n v = self.stencil.get_all_velocities()\n indices = self.istore[1:].copy()\n indices[1] += v[k].T[1]\n self.iload.append(np.concatenate([k[np.newaxis, :], indices]))","def transpose(self):\n return self.from_rep(self.rep.transpose())","def set_iload(self):\n k = self.istore[0]\n v = self.stencil.get_all_velocities()\n indices = self.istore[1:].copy()\n indices[0] += v[k].T[0]\n self.iload.append(np.concatenate([k[np.newaxis, :], indices]))","def set_iload(self):\n k = self.istore[0]\n v = self.stencil.get_all_velocities()\n indices = self.istore[1:].copy()\n indices[1] += v[k].T[2]\n self.iload.append(np.concatenate([k[np.newaxis, :], indices]))","def save_mem_load(self):\n if len(self.get_data_shape())==4 and self._img:\n data = np.zeros(self.get_data_shape())\n self._data = np.rot90(data)\n self._loaded_time_list = [0]\n self._data[..., 0] = np.rot90(self._img.dataobj[..., 0])\n else:\n self._loaded_time_list = [0]\n data = self._img.get_data(caching='unchanged')\n self._data = np.rot90(data)","def _collate_fn(batch):\r\n batch = list(zip(*batch))\r\n batch[0] = torch.stack(batch[0])\r\n batch[1] = list(batch[1])\r\n batch[2] = torch.stack(batch[2])\r\n return tuple(batch)","def load_ir(self):\n self.ir = self.read_var(self.irvar)\n self.ir = self.ir.astype('unicode')\n new_arr = []\n for p in range(np.shape(self.ir)[0]):\n new_arr.append(''.join(self.ir[p]))\n self.ir = new_arr\n self.ir = np.array(self.ir)\n self.test_shape(self.irvar, self.ir.shape, 1)","def _load_data(data, n_prev=max_length):\n docX, docY = [], []\n for i in range(len(data) - n_prev):\n docX.append(data.iloc[i:i + n_prev].as_matrix())\n docY.append(data.iloc[i + n_prev].as_matrix())\n alsX = np.array(docX)\n alsY = np.array(docY)\n\n return alsX, alsY","def load_data_wrapper():\r\n\r\n train_data, valid_data, tst_data = load_data()\r\n ## calling the function load_data()\r\n ## will return a tuple with three values for train, validation and test data\r\n ## storing the tuple values in separate three variables\r\n\r\n ## training_data:\r\n training_inputs = [np.reshape(x, (784,1)) for x in train_data[0]]\r\n ## reshaping the training inputs to 784x1 vector\r\n ## the required format for our neural network's input layer\r\n ## ---\r\n training_results = [vectorized_result(y) for y in train_data[1]]\r\n ## calling vectorized_result() function(see below)\r\n ## will convert the digit value in 10-dimensional vector\r\n ## the required format for our neural network's output layer\r\n ## ---\r\n training_data = zip(training_inputs, training_results)\r\n ## zipping together the training_inputs and training_results\r\n\r\n ## validation_data:\r\n validation_inputs = [np.reshape(x, (784,1)) for x in valid_data[0]]\r\n ## reshaping the validation inputs to 784x1 vector\r\n ## ---\r\n validation_data = zip(validation_inputs, valid_data[1])\r\n ## zipping together the validation_inputs and it's corresponding outputs\r\n\r\n ## test_data:\r\n test_inputs = [np.reshape(x, (784,1)) for x in tst_data[0]]\r\n ## reshaping the test inputs to 784x1 vector\r\n ## ---\r\n test_data = zip(test_inputs, tst_data[1])\r\n ## zipping together the test_inputs and it's corresponding outputs\r\n\r\n return (training_data, validation_data, test_data)","def reconstruct_input(self, ix):","def variable_tensor_size_collator(batch):\n assert isinstance(batch, Iterable)\n transpose = list(zip(*batch))\n for idx, field in enumerate(transpose):\n try:\n transpose[idx] = torch.stack(field)\n except Exception:\n continue\n return transpose","def load_data_wrapper():\r\n \r\n global training_inputs, training_results\r\n global validation_inputs, validation_results\r\n global test_inputs, test_results\r\n global num_samples, numpixels, num_test_samples\r\n \r\n tr_d, va_d, te_d = load_data()\r\n \r\n num_samples=len(tr_d[0])\r\n training_inputs=zeros([num_samples,numpixels])\r\n training_results=zeros([num_samples,10]) \r\n for j in range(num_samples):\r\n training_inputs[j,:] = reshape(tr_d[0][j], (numpixels))\r\n training_results[j,:] = vectorized_result(tr_d[1][j])\r\n# validation_inputs = [reshape(x, (numpixels)) for x in va_d[0]]\r\n# validation_results = [vectorized_result(y) for y in va_d[1]]\r\n\r\n num_test_samples=len(te_d[0])\r\n test_inputs=zeros([num_test_samples,numpixels])\r\n test_results=zeros([num_test_samples,10]) \r\n for j in range(num_test_samples):\r\n test_inputs[j,:] = reshape(te_d[0][j], (numpixels))\r\n test_results[j,:] = vectorized_result(te_d[1][j])","def _batchify(batch):\n im_name, im0, im1, im2, im3, im4, im5, im6, im7, im8, im9 = zip(*batch)\n im0 = nd.stack(*im0)\n im1 = nd.stack(*im1)\n im2 = nd.stack(*im2)\n im3 = nd.stack(*im3)\n im4 = nd.stack(*im4)\n im5 = nd.stack(*im5)\n im6 = nd.stack(*im6)\n im7 = nd.stack(*im7)\n im8 = nd.stack(*im8)\n im9 = nd.stack(*im9)\n return im_name, im0, im1, im2, im3, im4, im5, im6, im7, im8, im9","def _load_data(data, n_prev = 100):\n\n docX, docY = [], []\n for i in range(len(data)-n_prev):\n docX.append(data.iloc[i:i+n_prev].as_matrix())\n docY.append(data.iloc[i+n_prev].as_matrix())\n alsX = np.array(docX)\n alsY = np.array(docY)\n\n return alsX, alsY","def _convert_records_step(self, op: data_algebra.data_ops_types.OperatorPlatform, *, data_map: Dict[str, Any]):\n if op.node_name != \"ConvertRecordsNode\":\n raise TypeError(\n \"op was supposed to be a data_algebra.data_ops.ConvertRecordsNode\"\n )\n res = self._compose_polars_ops(op.sources[0], data_map=data_map)\n if isinstance(res, pl.LazyFrame):\n res = res.collect()\n res = op.record_map.transform(res, local_data_model=self)\n if self.use_lazy_eval and (not isinstance(res, pl.LazyFrame)):\n res = res.lazy()\n return res","def transpose_batch_time(inputs: torch.Tensor) ->torch.Tensor:\n return inputs.transpose(0, 1)","def _load_data(data, n_prev=3):\n docX, docY = [], []\n for i in range(len(data)-n_prev):\n docX.append(data.data.iloc[i:i+n_prev])\n docY.append(data.response.iloc[i+n_prev]) \n\n alsX = np.array(docX)\n alsY = np.array(docY)\n return np.matrix(alsX), np.matrix(alsY).T","def transpose(self):\n data = [list(col) for col in zip(*self.data)]\n return self.__class__(self.n, self.m, data)","def individual_collate(batch):\n\n data = batch\n\n collected_data = defaultdict(list)\n\n for i in range(len(list(data))):\n for k in data[i].keys():\n collected_data[k].append(data[i][k])\n\n for k in collected_data.keys():\n collected_data[k] = torch.stack(collected_data[k])\n\n return collected_data","def _load(self, load_dict):\n for key in list(load_dict.keys()):\n # We delete keys over time:\n if key in load_dict:\n if SparseResult.IDENTIFIER in key:\n new_key = key.split(SparseResult.IDENTIFIER)[0]\n matrix = SparseParameter._reconstruct_matrix(load_dict[key])\n self._data[new_key] = matrix\n else:\n self._data[key] = load_dict[key]","def loadasem(loads, IBC, neq):\r\n RHSG = np.zeros([neq])\r\n nl = loads.shape[0]\r\n for i in range(nl):\r\n il = int(loads[i, 0])\r\n ilx = IBC[il, 0]\r\n ily = IBC[il, 1]\r\n ilT = IBC[il, 2]\r\n if ilx != -1:\r\n RHSG[ilx] = loads[i, 1]\r\n if ily != -1:\r\n RHSG[ily] = loads[i, 2]\r\n if ilT != -1:\r\n RHSG[ilT] = loads[i, 3]\r\n return RHSG","def load_data():\n f = gzip.open('mnist.pkl.gz', 'rb')\n training_data, validation_data, test_data = pickle.load(f, encoding=\"latin1\")\n f.close()\n \n X_train = [np.reshape(x, (784, 1)) for x in training_data[0]]\n Y_train = [vectorized_result(y) for y in training_data[1]]\n \n X_validation = [np.reshape(x, (784, 1)) for x in validation_data[0]]\n Y_validation = validation_data[1]\n \n X_test = [np.reshape(x, (784, 1)) for x in test_data[0]]\n Y_test = test_data[1]\n \n return (X_train, Y_train, X_validation, Y_validation, X_test, Y_test)","def load_as_files(self, lazy=True):\n # Handle lazy load\n if lazy:\n try:\n questions = read_file_data('questions', self.inputs_dir)\n answers = read_file_data('answers', self.inputs_dir)\n questions_vocabs = read_file_data('questions_vocabs', self.inputs_dir)\n answers_vocabs = read_file_data('answers_vocabs', self.inputs_dir)\n except Exception as e:\n print('Failed to lazy load !', e)\n questions, answers, questions_vocabs, answers_vocabs = self.sub.load_as_raw()\n save_file_data('questions', questions, self.inputs_dir)\n save_file_data('answers', answers, self.inputs_dir)\n save_file_data('questions_vocabs', questions_vocabs, self.inputs_dir)\n save_file_data('answers_vocabs', answers_vocabs, self.inputs_dir)\n else:\n questions, answers, questions_vocabs, answers_vocabs = self.sub.load_as_raw()\n\n # It will always use vi as src en as output\n X_train, X_test, y_train, y_test = train_test_split(questions, answers, test_size=0.2, random_state=42)\n X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train, test_size=0.25, random_state=42)\n\n # Train\n save_list_to_file(X_train, '{}/train.vi'.format(self.inputs_dir))\n save_list_to_file(y_train, '{}/train.en'.format(self.inputs_dir))\n\n # Valid\n save_list_to_file(X_valid, '{}/dev.vi'.format(self.inputs_dir))\n save_list_to_file(y_valid, '{}/dev.en'.format(self.inputs_dir))\n\n # Test\n save_list_to_file(X_test, '{}/test.vi'.format(self.inputs_dir))\n save_list_to_file(y_test, '{}/test.en'.format(self.inputs_dir))\n\n # vocab\n save_list_to_file(questions_vocabs, '{}/vocab.vi'.format(self.inputs_dir))\n save_list_to_file(answers_vocabs, '{}/vocab.en'.format(self.inputs_dir))","def load_data(self, t):\n self.ensure_datafiles()\n datafile = os.path.join(self.data_dir, ALL_DATA[t])\n data = sio.loadmat(datafile)\n return data['X'].transpose(3, 0, 1, 2), data['y']","def triples(self):\n return pd.concat((self._load_train(), self._load_valid(), self._load_test()))","def transpose_volumes(volumes, slice_direction):\n if (slice_direction == 'axial'):\n tr_volumes = volumes\n elif(slice_direction == 'sagittal'):\n tr_volumes = [np.transpose(x, (2, 0, 1)) for x in volumes]\n elif(slice_direction == 'coronal'):\n tr_volumes = [np.transpose(x, (1, 0, 2)) for x in volumes]\n else:\n print('undefined slice direction:', slice_direction)\n tr_volumes = volumes\n return tr_volumes","def transpose(self, transposition):\r\n top_node = self.top_node\r\n self.top_node = self.transpose_helper(top_node, transposition)\r\n int(self.top_node.split('|')[0][1::].strip('()').split(', ')[0])\r\n self.run_clean_up()","def load(self):\n self.word2vec, self.img2sentence, self.word_freq, self.num_words, self.word2idx, self.idx2word = pickle.load(open(self.save_file, 'rb'))","def test_unstack3():\n x = np.arange(1, 49).reshape((4, 3, 2, 2)).astype(np.float64)\n axis = 1\n x_tensor = paddle.to_tensor(x)\n out_list = paddle.unstack(x_tensor, axis=axis)\n length = len(out_list)\n for i in range(length):\n ept = x[:, i, :, :]\n npt.assert_allclose(out_list[i].numpy(), ept)","def imprimir_serializado(self, tipo_tag, tag, transpose, only_buffer,\n extra_data):\n self._info(\"imprimir_serializado\")\n try:\n self.controller.imprimir_serializado(tipo_tag, tag, transpose,\n only_buffer, extra_data)\n except Exception as exc:\n # Agarramos todos los errores de impresión que no hayamos agarrrado\n self.error_impresion()\n self.logger.exception(exc)","def transpose(self):\n return self._transpose","def _ixs(self, i, axis=0):\n result = super()._ixs(i, axis=axis)\n\n # Override columns\n if axis == 0:\n if isinstance(i, slice):\n return self[i]\n else:\n label = self.index[i]\n if isinstance(label, Index):\n # a location index by definition\n result = self.take(i, axis=axis)\n copy = True\n else:\n new_values = self._data.fast_xs(i)\n\n # if we are a copy, mark as such\n copy = (\n isinstance(new_values, np.ndarray) and new_values.base is None\n )\n result = self._constructor_sliced(\n new_values,\n index=self.columns,\n name=self.index[i],\n dtype=new_values.dtype,\n au_columns=self.au_columns,\n emotion_columns=self.emotion_columns,\n facebox_columns=self.facebox_columns,\n landmark_columns=self.landmark_columns,\n facepose_columns=self.facepose_columns,\n gaze_columns=self.gaze_columns,\n time_columns=self.time_columns,\n design_columns=self.design_columns,\n filename=self.filename,\n sampling_freq=self.sampling_freq,\n detector=self.detector,\n features=self.features,\n sessions=self.sessions,\n )\n result._set_is_copy(self, copy=copy)\n return result\n\n else:\n \"\"\"\n Notes\n -----\n If slice passed, the resulting data will be a view\n \"\"\"\n\n label = self.columns[i]\n if isinstance(i, slice):\n # need to return view\n lab_slice = slice(label[0], label[-1])\n return self.loc[:, lab_slice]\n else:\n if isinstance(label, Index):\n return self._take(i, axis=1, convert=True)\n\n index_len = len(self.index)\n\n # if the values returned are not the same length\n # as the index (iow a not found value), iget returns\n # a 0-len ndarray. This is effectively catching\n # a numpy error (as numpy should really raise)\n values = self._data.iget(i)\n\n if index_len and not len(values):\n values = np.array([np.nan] * index_len, dtype=object)\n result = self._constructor_sliced(\n values,\n index=self.index,\n name=label,\n fastpath=True,\n au_columns=self.au_columns,\n emotion_columns=self.emotion_columns,\n facebox_columns=self.facebox_columns,\n landmark_columns=self.landmark_columns,\n facepose_columns=self.facepose_columns,\n gaze_columns=self.gaze_columns,\n time_columns=self.time_columns,\n design_columns=self.design_columns,\n filename=self.filename,\n sampling_freq=self.sampling_freq,\n detector=self.detector,\n features=self.features,\n sessions=self.sessions,\n )\n\n # this is a cached value, mark it so\n result._set_as_cached(label, self)\n return result","def array(self):\n aa = list(map(np.asarray, self.loader_array.flat))\n return np.stack(aa, axis=0).reshape(self.output_shape)","def collate_fn(self, batch):\n images = list()\n targets = list()\n\n for b in batch:\n images.append(b[0])\n targets.append(b[1])\n\n # images = torch.stack(images, dim=0)\n\n return images, targets # tensor (N, 3, 300, 300), 3 lists of N tensors each","def _assemble_tiles(i, n, tile, tsincr_g, output_dir, outtype):\n # pylint: disable=too-many-arguments\n tsincr_file = os.path.join(output_dir, '{}_{}.npy'.format(outtype, n))\n tsincr = np.load(file=tsincr_file)\n tsincr_g[tile.top_left_y:tile.bottom_right_y, tile.top_left_x:tile.bottom_right_x] = tsincr[:, :, i]","def convert_transpose(g, op, block):\n\n perm = op.attr(\"axis\")\n out = _op.transpose(g.get_node(op.input(\"X\")[0]), axes=perm)\n g.add_node(op.output(\"Out\")[0], out)","def convert_train(ndata, ndim):\r\n print ('Converting training data ... ')\r\n x = np.zeros([ndata, ndim])\r\n y = np.zeros([ndata])\r\n \r\n for i in range(0, len(flist) - 2):\r\n batchn = filepath + flist[i]\r\n temp = read(batchn)\r\n x[i * 10000:(i + 1) * 10000] = temp['data']\r\n y[i * 10000:(i + 1) * 10000] = temp['labels']\r\n \"\"\"\r\n i=0\r\n batchn = filepath + flist[i]\r\n\r\n temp = read(batchn)\r\n\r\n x[i * 10000:(i + 1) * 10000] = temp['data']\r\n\r\n y[i * 10000:(i + 1) * 10000] = temp['labels']\r\n \"\"\"\r\n return x, y","def split_and_load(arrs, _ctxs):\n # TODO Replace split_array() with gluon.utils.split_data() once targeting MXNet 1.7\n assert isinstance(arrs, (list, tuple))\n # split and load\n loaded_arrs = [[i.as_in_context(ctx) for i, ctx in zip(split_array(arr, len(_ctxs)), _ctxs)]\n for arr in arrs]\n return zip(*loaded_arrs)","def reformat(dataset):\n x = dataset[:, 1] \n x = np.stack(x) # reshape to (n, mel bands, timesteps)\n x = np.expand_dims(np.moveaxis(x, 1, -1), axis=3) # reformat x to (n, timesteps, mel bands, 1) \n y = dataset[:, 2] \n y = np.moveaxis(np.stack(y), 1, -1) # reformat y to (n, timesteps, 8)\n return x, y","def flatten(file_name):\n dataset = pickle.load(open(file_name, 'rb'))\n train_data = dataset['train']\n test_data = dataset['test']\n\n train_data = [y for x in train_data for y in x]\n test_data = [y for x in test_data for y in x]\n\n train_data=generate_binary_vectors(train_data,False)\n test_data=generate_binary_vectors(test_data,False)\n\n return train_data, test_data","def test_unstack2():\n x = np.arange(1, 25).reshape((4, 2, 3)).astype(np.float32)\n axis = 2\n x_tensor = paddle.to_tensor(x)\n out_list = paddle.unstack(x_tensor, axis=axis)\n length = len(out_list)\n for i in range(length):\n ept = x[:, :, i]\n npt.assert_allclose(out_list[i].numpy(), ept)","def _load_wt(self, x):\n W = x[:self.dimY*self.dimX].reshape(self.dimY,self.dimX) \n W = W.transpose() # Coz W is stored in such way\n # print(W)\n T = x[self.dimY*self.dimX:].reshape(self.dimY,self.dimY).transpose() \n return W, T","def transpose(seqseq):\n return zip(*seqseq)","def restore(self, ids):\n with self._db_connection(transaction=True) as transaction:\n for id_ in ids:\n transaction.restore_dataset(id_)","def convert_unstack(g, op, block):\n\n x = g.get_node(op.input(\"X\")[0])\n axis = op.attr(\"axis\")\n indices_or_sections = len(op.output(\"Y\"))\n outs = _op.split(x, indices_or_sections=indices_or_sections, axis=axis)\n for i, out in enumerate(outs):\n out = _op.squeeze(out, axis=axis)\n g.add_node(op.output(\"Y\")[i], out)","def T(self):\n return Op('transpose', self)","def _load_a_couple0(self, path):\n assert(self._initialisation)\n X = pd.read_hdf(path[0], key='s')\n Y = np.load(path[1])\n return X , Y","def transpose_volumes(volumes, slice_direction):\n if (slice_direction == 'axial'):\n tr_volumes = volumes\n elif(slice_direction == 'sagittal'):\n if isinstance(volumes, list) or len(volumes.shape) > 3:\n tr_volumes = [np.transpose(x, (2, 0, 1)) for x in volumes]\n else:\n tr_volumes = np.transpose(volumes, (2, 0, 1))\n elif(slice_direction == 'coronal'):\n if isinstance(volumes, list) or len(volumes.shape) > 3:\n tr_volumes = [np.transpose(x, (1, 0, 2)) for x in volumes]\n else:\n tr_volumes = np.transpose(volumes, (1, 0, 2))\n else:\n print('undefined slice direction:', slice_direction)\n tr_volumes = volumes\n return tr_volumes","def load(self, i: int) -> np.ndarray:\n raise NotImplementedError(\"Do not call load from BaseLoader\")","def setup_transposed_data(self, data: List[Dict[str, Any]]):\n output = []\n open = []\n low = []\n high = []\n volume = []\n for dat in data:\n open.append(dat[\"open\"])\n low.append(dat[\"low\"])\n high.append(dat[\"high\"])\n volume.append(dat[\"volume\"])\n output.append(dat[\"close\"])\n input = [open, low, high, volume]\n return input, output","def transpose(x: torch.Tensor, dims):\n _dims = list(dims)\n for i in range(len(_dims)):\n if _dims[i] != i:\n x = x.transpose(i, _dims[i])\n j = _dims.index(i)\n _dims[i], _dims[j] = i, _dims[i]\n return x","def Zip(datasets):\n return tf.data.Dataset.zip(datasets)","def load_X():\n x1 = np.asarray([-1, -1, 1, -1, 1, -1, -1, 1]).reshape((1, 8))\n x2 = np.asarray([-1, -1, -1, -1, -1, 1, -1, -1]).reshape((1, 8))\n x3 = np.asarray([-1, 1, 1, -1, -1, 1, -1, 1]).reshape((1, 8))\n X = np.vstack([x1, x2, x3])\n\n return X","def transpose(self, *args, **kwargs):\n return _image.image_transpose(self, *args, **kwargs)","def load(self, record: api.Record) -> api.DataRecord:\n\n def _index_dict_to_arr(d, keys):\n if isinstance(keys, list):\n return np.array([d[k] for k in keys])\n else:\n return np.array(d[keys])\n\n X = {k: _index_dict_to_arr(record, v) for k, v in self.inputs.items()}\n if self.mode == api.RecordMode.TRAIN or self.mode == api.RecordMode.VALIDATION:\n y = {k: _index_dict_to_arr(record, v) for k, v in self.outputs.items()}\n if self.sample_weights is not None:\n w = {k: np.array(record[v]) for k, v in self.sample_weights.items()}\n return (X, y, w)\n else:\n return (X, y)\n else:\n return (X,)","def load_chunks(self):\n for key, array in self.chunks.items():\n loaded_array = np.asarray(array)\n self.chunks[key] = loaded_array","def test_unstack():\n x = np.arange(1, 13).reshape((3, 2, 2)).astype(np.int32)\n axis = 0\n x_tensor = paddle.to_tensor(x)\n out_list = paddle.unstack(x_tensor, axis=axis)\n length = len(out_list)\n for i in range(length):\n ept = x[i, :, :]\n npt.assert_allclose(out_list[i].numpy(), ept)","def load_data(self):","def retrieval_collate(data):\n # separate source and target sequences\n t2i_batch, i2t_batch = list(zip(*data))\n\n # t2i\n def generate_inputs(_batch):\n sent, att_feats, img_masks, box_feats, obj_labels, pos_labels, img_ids, langs = zip(\n *_batch)\n # sent = np.array(sent)\n _sent = []\n _pos_labels = []\n _img_ids = []\n _langs = []\n for s, p, i, l in zip(sent, pos_labels, img_ids, langs):\n _sent.extend(s)\n _pos_labels.extend(p)\n _img_ids.extend(i)\n _langs.extend(l)\n pos_labels = _pos_labels\n img_ids = _img_ids\n\n x_img = torch.stack(att_feats, dim=0)\n img_loc = torch.stack(box_feats, dim=0)\n x_img_mask = torch.stack(img_masks, dim=0)\n x_obj_labels = torch.stack(obj_labels, dim=0)\n\n x_img = x_img.view([-1] + list(tuple(x_img.size()[2:])))\n img_loc = img_loc.view([-1] + list(tuple(img_loc.size()[2:])))\n x_img_mask = x_img_mask.view([-1] + list(tuple(x_img_mask.size()[2:])))\n x_obj_labels = x_obj_labels.view([-1] + list(tuple(x_obj_labels.size()[2:])))\n\n _inputs = [batch_sentences(_sent, _langs),\n [x_img,\n x_img_mask,\n img_loc,\n x_obj_labels,\n pos_labels,\n img_ids] # google_replace\n ]\n return _inputs\n\n _t2i_out = generate_inputs(t2i_batch) if t2i_batch is not None else None\n _i2t_out = generate_inputs(i2t_batch) if i2t_batch is not None else None\n all_return_results = [_t2i_out, _i2t_out]\n return all_return_results","def sinterstore(self, dest, keys, *args):\r\n keys = list_or_args('sinterstore', keys, args)\r\n return self.format_inline('SINTERSTORE', dest, *keys)","def imed_collate(batch):\n error_msg = \"batch must contain tensors, numbers, dicts or lists; found {}\"\n elem_type = type(batch[0])\n if torch.is_tensor(batch[0]):\n stacked = torch.stack(batch, 0)\n return stacked\n elif elem_type.__module__ == 'numpy' and elem_type.__name__ != 'str_' \\\n and elem_type.__name__ != 'string_':\n elem = batch[0]\n if elem_type.__name__ == 'ndarray':\n # array of string classes and object\n if re.search('[SaUO]', elem.dtype.str) is not None:\n raise TypeError(error_msg.format(elem.dtype))\n return torch.stack([torch.from_numpy(b) for b in batch], 0)\n if elem.shape == (): # scalars\n py_type = float if elem.dtype.name.startswith('float') else int\n return __numpy_type_map[elem.dtype.name](list(map(py_type, batch)))\n elif isinstance(batch[0], int_classes):\n return torch.LongTensor(batch)\n elif isinstance(batch[0], float):\n return torch.DoubleTensor(batch)\n elif isinstance(batch[0], string_classes):\n return batch\n elif isinstance(batch[0], collections.abc.Mapping):\n return {key: imed_collate([d[key] for d in batch]) for key in batch[0]}\n elif isinstance(batch[0], collections.abc.Sequence):\n return [imed_collate(samples) for samples in batch]\n\n return batch","def __data_generation(self, folder_id, file_id, el_ids):\n self.reload(folder_id, file_id)\n X = self.X[el_ids]\n Y = self.apply_preprocess_y(self.Y[:,:,:,el_ids])\n Y = np.rollaxis(Y,-1) #6,72,72,BS\n Y = Y.swapaxes(-2,-1)\n return X,Y","def dataset_to_tensors(dataset):\r\n tensor_num = len(dataset[0])\r\n tensors = [torch.LongTensor([sample[i] for sample in dataset]) for i in range(tensor_num)]\r\n return tensors","def temporally_align_data_interfaces(self):\n pass","def load_data(): \n\tdf = pandas.read_csv('data/iris.data', header=None)\n\ty = df.iloc[0:df.shape[0], 4].values\n\ty = np.where(y == 'Iris-setosa', 0, y)\n\ty = np.where(y == 'Iris-versicolor', 1, y)\n\ty = np.where(y == 'Iris-virginica', 2, y)\n\tx = df.iloc[0:df.shape[0], 0:4].values\n\tx = tuple(x)\n\ty = tuple(y)\n\ttraining_inputs = x[0:40] + x[50:90] + x[100:140]\n\ttraining_results = y[0:40] + y[50:90] + y[100:140]\n\ttraining_data = (training_inputs, training_results)\n\ttest_inputs = x[40:50] + x[90:100] + x[140:150]\n\ttest_results = y[40:50] + y[90:1000] + y[140:150]\n\ttest_data = (test_inputs, test_results)\n\treturn (training_data, test_data)","def collate_fn(self, batch):\n images = list()\n boxes = list()\n labels = list()\n difficulties = list()\n\n for b in batch:\n images.append(b[0])\n boxes.append(b[1])\n labels.append(b[2])\n difficulties.append(b[3])\n\n images = torch.stack(images, dim=0)\n\n return images, boxes, labels, difficulties # tensor (N, 3, 300, 300), 3 lists of N tensors each","def T(self):\n return F.Transpose.apply(self)","def test_transpose():\n x = np.array([\n [1, 2],\n [3, 4]\n ])\n y = np.array([\n [5, 6],\n [7, 8]\n ])\n z = np.dstack([x, y])\n return z, z.transpose(1, 0, 2)","def to_ir(self):","def test_unstack1():\n x = np.arange(1, 25).reshape((4, 2, 3)).astype(np.float32)\n axis = -1\n x_tensor = paddle.to_tensor(x)\n out_list = paddle.unstack(x_tensor, axis=axis)\n length = len(out_list)\n for i in range(length):\n ept = x[:, :, i]\n npt.assert_allclose(out_list[i].numpy(), ept)","def __data_generation(self, folder_id, file_id, el_ids):\n self.reload(folder_id, file_id)\n X = np.array(self.X.iloc[el_ids]).reshape(self.batch_size, len(self.used_variables), self.lev)\n Y = self.Y[:,:,:,el_ids]\n return X,Y","def _read_interpops(self, sheet) -> None:\n tables, start_rows = read_tables(sheet)\n assert len(tables) % 3 == 0, \"There should be 3 subtables for every transfer\"\n self.interpops = []\n for i in range(0, len(tables), 3):\n self.interpops.append(TimeDependentConnections.from_tables(tables[i : i + 3], \"interaction\"))\n return","def transpose(self):\n trans = Matrix(self.ncols,self.nrows)\n for i in range(self.nrows):\n for j in range(self.ncols):\n trans.matrix[j][i] = self.matrix[i][j]\n return trans","def _transpose(h_lines: List[Line]) -> List[Line]:\n\n return [Line([line.get_field(i) for line in h_lines]) for i in range(SIZE)]","def transpose():\n\tdata = request.get_json()\n\tm=int(data[\"m\"])\n\tn=int(data[\"n\"])\n\tfor i in range (0,m):\n\t\tfor j in range(0,n):\n\t\t\tdata[\"Matrix\"][i][j]=data[\"Matrix\"][i][j]*100\n\treturn json.dumps(data[\"Matrix\"])\n\t\n\treturn json.dumps(data[\"Matrix\"])","def transpose(tensor):\n raise NotImplementedError","def load_all(digit):\n\n tests = load(digit, type_str='test')\n trains = load(digit, type_str='train') # choo choo\n \n return numpy.concatenate((tests, trains), axis=0)","def pack(self):\n if self.stack:\n # Should be a straight forward concatenation\n packed = torch.cat(self.data, dim=0)\n else:\n # Need to account for padding values\n from netharn.data.collate import padded_collate\n inbatch = list(ub.flatten(self.data))\n packed = padded_collate(inbatch, fill_value=self.padding_value)\n return packed","def slide_collate(data):\n # separate source and target sequences\n sent, att_feats, img_masks, box_feats, img_ids,cur_label = list(zip(*data))\n\n # t2i\n def generate_inputs():\n # sent = np.array(sent)\n\n _sent = []\n _img_ids = []\n _labels = []\n for s, i, p in zip(sent, img_ids, cur_label):\n _sent.extend(s)\n _img_ids.extend(i)\n _labels.extend(p)\n\n\n x_img = torch.stack(att_feats, dim=0)\n img_loc = torch.stack(box_feats, dim=0)\n x_img_mask = torch.stack(img_masks, dim=0)\n\n x_img = x_img.view([-1] + list(tuple(x_img.size()[2:])))\n img_loc = img_loc.view([-1] + list(tuple(img_loc.size()[2:])))\n x_img_mask = x_img_mask.view([-1] + list(tuple(x_img_mask.size()[2:])))\n\n _inputs = [batch_sentences(_sent),\n [x_img,\n x_img_mask,\n img_loc,\n _img_ids],\n _labels\n ]\n return _inputs\n\n all_return_results = generate_inputs()\n return all_return_results"],"string":"[\n \"def transpose():\",\n \"def transpose_load_concat(self, **kwargs):\\n if self.mask_train:\\n datamask=self.add_mask()\\n thedatas={}\\n for key, value in kwargs.items():\\n if not self.mask_train:\\n thedatas[key]=value.X_train.transpose('a','x','y','features').values\\n if self.mask_train:\\n temp=value.X_train.transpose('a','x','y','features').values\\n thedatas[key]=np.where(np.repeat(datamask['X_train'].values[...,np.newaxis], 4, axis=3)==0, 0, temp)\\n label=value.X_train_label.values\\n if len(kwargs) > 1:\\n X_train=np.concatenate(list(thedatas.values()), axis=3)\\n if len(kwargs)==1:\\n X_train=np.squeeze(np.asarray(list(thedatas.values())))\\n return X_train, label\",\n \"def transpose(self) -> None:\\n ...\",\n \"def transpose(self):\\n pass\",\n \"def load_data_wrapper():\\n\\ttr_d, te_d = load_data()\\n\\ttraining_inputs = [np.reshape(x, (4, 1)) for x in tr_d[0]]\\n\\ttraining_results = [vectorized_result(y) for y in tr_d[1]]\\n\\ttraining_data = zip(training_inputs, training_results)\\n\\ttest_inputs = [np.reshape(x, (4, 1)) for x in te_d[0]]\\n\\ttest_data = zip(test_inputs, te_d[1])\\n\\treturn (training_data, test_data)\",\n \"def load_data_wrapper():\\n tr_d, va_d, te_d = load_data()\\n training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]\\n training_results = [vectorized_result(y) for y in tr_d[1]]\\n training_data = zip(training_inputs, training_results)\\n validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]\\n validation_data = zip(validation_inputs, va_d[1])\\n test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]\\n test_data = zip(test_inputs, te_d[1])\\n return (training_data, validation_data, test_data)\",\n \"def load_data_wrapper():\\n tr_d, va_d, te_d = load_data()\\n training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]\\n training_results = [vectorized_result(y) for y in tr_d[1]]\\n training_data = zip(training_inputs, training_results)\\n validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]\\n validation_data = zip(validation_inputs, va_d[1])\\n test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]\\n test_data = zip(test_inputs, te_d[1])\\n return (training_data, validation_data, test_data)\",\n \"def load_data_wrapper():\\n tr_d, va_d, te_d = load_data()\\n training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]\\n training_results = [vectorized_result(y) for y in tr_d[1]]\\n training_data = list(zip(training_inputs, training_results))\\n validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]\\n validation_data = list(zip(validation_inputs, va_d[1]))\\n test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]\\n test_data = list(zip(test_inputs, te_d[1]))\\n return (training_data, validation_data, test_data)\",\n \"def irtranspose(x: torch.Tensor, dims):\\n _dims = list(dims)\\n _ir_dims = [_dims.index(i) for i in range(len(_dims))]\\n return transpose(x, _ir_dims)\",\n \"def set_iload(self):\\n k = self.istore[0]\\n v = self.stencil.get_all_velocities()\\n indices = self.istore[1:] + v[k].T\\n self.iload.append(np.concatenate([k[np.newaxis, :], indices]))\",\n \"def unzip_batch(batch):\\n unzip = [[i for i, j in batch],\\n [j for i, j in batch]]\\n return np.transpose(unzip[0]), np.transpose(unzip[1])\",\n \"def transpose_chunks(self, order: tuple) -> None:\\n for key, array in self.chunks.items():\\n self.chunks[key] = array.transpose(order)\",\n \"def load_data_wrapper():\\n\\n tr_d, va_d, te_d = load_data()\\n\\n training_inputs = [np.reshape(a=x, newshape=(784, 1)) for x in tr_d[0]]\\n training_results = [vectorized_result(y) for y in tr_d[1]]\\n training_data = zip(training_inputs, training_results)\\n # Need to do list(zip(...)) instead of just zip(...) in Python 3\\n # training_data = list(zip(training_inputs, training_results))\\n\\n validation_inputs = [np.reshape(a=x, newshape=(784, 1)) for x in va_d[0]]\\n validation_data = zip(validation_inputs, va_d[1])\\n # validation_data = list(zip(validation_inputs, va_d[1]))\\n\\n test_inputs = [np.reshape(a=x, newshape=(784, 1)) for x in te_d[0]]\\n test_data = zip(test_inputs, te_d[1])\\n # test_data = list(zip(test_inputs, te_d[1]))\\n\\n return training_data, validation_data, test_data\",\n \"def load_dataset():\\n temp = gzip.open('mnist.pkl.gz')\\n train, val , test = pickle.load(temp,encoding='latin1')\\n temp.close()\\n train_inp = [np.reshape(x, (784,1)) for x in train[0]]\\n train_outp = [one_hot(y) for y in train[1]]\\n training_data = zip(train_inp, train_outp)\\n validation_inp = [np.reshape(x, (784, 1)) for x in val[0]]\\n validation_data = zip(validation_inp, val[1])\\n test_inp = [np.reshape(x, (784, 1)) for x in test[0]]\\n test_data = zip(test_inp, test[1])\\n return (training_data,validation_data,test_data)\",\n \"def fortran_storage(a):\\n if NumPy_type(a) == 'Numeric' or NumPy_type(a) == 'numarray':\\n return transpose(transpose(a).copy())\\n else:\\n import numpy\\n return numpy.asarray(a, fortran=True)\",\n \"def load_data():\\n (trainx, trainy), (valx, valy), (testx, testy) = pickle.load(gzip.open(\\\"data/mnist_one_hot.pkl.gz\\\"),\\n encoding=\\\"latin1\\\")\\n trainy = np.argmax(trainy, axis=1)\\n valy = np.argmax(valy, axis=1)\\n testy = np.argmax(testy, axis=1)\\n trainx = trainx * 2 - 1\\n valx = valx * 2 - 1\\n testx = testx * 2 - 1\\n return (trainx.reshape(-1, 1, 28, 28), trainy), (valx.reshape(-1, 1, 28, 28), valy), (testx.reshape(-1, 1, 28, 28),\\n testy)\",\n \"def set_iload(self):\\n k = self.istore[0]\\n ksym = self.stencil.get_symmetric()[k][np.newaxis, :]\\n v = self.stencil.get_all_velocities()\\n indices = self.istore[1:] + v[k].T\\n self.iload.append(np.concatenate([ksym, indices]))\",\n \"def transpose(m):\\n\\n pass\",\n \"def transpose(self):\\n order = list(self.order)\\n order[-2], order[-1] = order[-1], order[-2]\\n self.order = order\",\n \"def rearrange_batch(batch):\\n return list(zip(*batch))\",\n \"def unpackRecords(self,unpackTypes):\\n for record in self.records:\\n if record.name in unpackTypes:\\n record.load(unpack=True)\",\n \"def set_iload(self):\\n k = self.istore[0]\\n v = self.stencil.get_all_velocities()\\n indices = self.istore[1:].copy()\\n indices[1] += v[k].T[1]\\n self.iload.append(np.concatenate([k[np.newaxis, :], indices]))\",\n \"def transpose(self):\\n return self.from_rep(self.rep.transpose())\",\n \"def set_iload(self):\\n k = self.istore[0]\\n v = self.stencil.get_all_velocities()\\n indices = self.istore[1:].copy()\\n indices[0] += v[k].T[0]\\n self.iload.append(np.concatenate([k[np.newaxis, :], indices]))\",\n \"def set_iload(self):\\n k = self.istore[0]\\n v = self.stencil.get_all_velocities()\\n indices = self.istore[1:].copy()\\n indices[1] += v[k].T[2]\\n self.iload.append(np.concatenate([k[np.newaxis, :], indices]))\",\n \"def save_mem_load(self):\\n if len(self.get_data_shape())==4 and self._img:\\n data = np.zeros(self.get_data_shape())\\n self._data = np.rot90(data)\\n self._loaded_time_list = [0]\\n self._data[..., 0] = np.rot90(self._img.dataobj[..., 0])\\n else:\\n self._loaded_time_list = [0]\\n data = self._img.get_data(caching='unchanged')\\n self._data = np.rot90(data)\",\n \"def _collate_fn(batch):\\r\\n batch = list(zip(*batch))\\r\\n batch[0] = torch.stack(batch[0])\\r\\n batch[1] = list(batch[1])\\r\\n batch[2] = torch.stack(batch[2])\\r\\n return tuple(batch)\",\n \"def load_ir(self):\\n self.ir = self.read_var(self.irvar)\\n self.ir = self.ir.astype('unicode')\\n new_arr = []\\n for p in range(np.shape(self.ir)[0]):\\n new_arr.append(''.join(self.ir[p]))\\n self.ir = new_arr\\n self.ir = np.array(self.ir)\\n self.test_shape(self.irvar, self.ir.shape, 1)\",\n \"def _load_data(data, n_prev=max_length):\\n docX, docY = [], []\\n for i in range(len(data) - n_prev):\\n docX.append(data.iloc[i:i + n_prev].as_matrix())\\n docY.append(data.iloc[i + n_prev].as_matrix())\\n alsX = np.array(docX)\\n alsY = np.array(docY)\\n\\n return alsX, alsY\",\n \"def load_data_wrapper():\\r\\n\\r\\n train_data, valid_data, tst_data = load_data()\\r\\n ## calling the function load_data()\\r\\n ## will return a tuple with three values for train, validation and test data\\r\\n ## storing the tuple values in separate three variables\\r\\n\\r\\n ## training_data:\\r\\n training_inputs = [np.reshape(x, (784,1)) for x in train_data[0]]\\r\\n ## reshaping the training inputs to 784x1 vector\\r\\n ## the required format for our neural network's input layer\\r\\n ## ---\\r\\n training_results = [vectorized_result(y) for y in train_data[1]]\\r\\n ## calling vectorized_result() function(see below)\\r\\n ## will convert the digit value in 10-dimensional vector\\r\\n ## the required format for our neural network's output layer\\r\\n ## ---\\r\\n training_data = zip(training_inputs, training_results)\\r\\n ## zipping together the training_inputs and training_results\\r\\n\\r\\n ## validation_data:\\r\\n validation_inputs = [np.reshape(x, (784,1)) for x in valid_data[0]]\\r\\n ## reshaping the validation inputs to 784x1 vector\\r\\n ## ---\\r\\n validation_data = zip(validation_inputs, valid_data[1])\\r\\n ## zipping together the validation_inputs and it's corresponding outputs\\r\\n\\r\\n ## test_data:\\r\\n test_inputs = [np.reshape(x, (784,1)) for x in tst_data[0]]\\r\\n ## reshaping the test inputs to 784x1 vector\\r\\n ## ---\\r\\n test_data = zip(test_inputs, tst_data[1])\\r\\n ## zipping together the test_inputs and it's corresponding outputs\\r\\n\\r\\n return (training_data, validation_data, test_data)\",\n \"def reconstruct_input(self, ix):\",\n \"def variable_tensor_size_collator(batch):\\n assert isinstance(batch, Iterable)\\n transpose = list(zip(*batch))\\n for idx, field in enumerate(transpose):\\n try:\\n transpose[idx] = torch.stack(field)\\n except Exception:\\n continue\\n return transpose\",\n \"def load_data_wrapper():\\r\\n \\r\\n global training_inputs, training_results\\r\\n global validation_inputs, validation_results\\r\\n global test_inputs, test_results\\r\\n global num_samples, numpixels, num_test_samples\\r\\n \\r\\n tr_d, va_d, te_d = load_data()\\r\\n \\r\\n num_samples=len(tr_d[0])\\r\\n training_inputs=zeros([num_samples,numpixels])\\r\\n training_results=zeros([num_samples,10]) \\r\\n for j in range(num_samples):\\r\\n training_inputs[j,:] = reshape(tr_d[0][j], (numpixels))\\r\\n training_results[j,:] = vectorized_result(tr_d[1][j])\\r\\n# validation_inputs = [reshape(x, (numpixels)) for x in va_d[0]]\\r\\n# validation_results = [vectorized_result(y) for y in va_d[1]]\\r\\n\\r\\n num_test_samples=len(te_d[0])\\r\\n test_inputs=zeros([num_test_samples,numpixels])\\r\\n test_results=zeros([num_test_samples,10]) \\r\\n for j in range(num_test_samples):\\r\\n test_inputs[j,:] = reshape(te_d[0][j], (numpixels))\\r\\n test_results[j,:] = vectorized_result(te_d[1][j])\",\n \"def _batchify(batch):\\n im_name, im0, im1, im2, im3, im4, im5, im6, im7, im8, im9 = zip(*batch)\\n im0 = nd.stack(*im0)\\n im1 = nd.stack(*im1)\\n im2 = nd.stack(*im2)\\n im3 = nd.stack(*im3)\\n im4 = nd.stack(*im4)\\n im5 = nd.stack(*im5)\\n im6 = nd.stack(*im6)\\n im7 = nd.stack(*im7)\\n im8 = nd.stack(*im8)\\n im9 = nd.stack(*im9)\\n return im_name, im0, im1, im2, im3, im4, im5, im6, im7, im8, im9\",\n \"def _load_data(data, n_prev = 100):\\n\\n docX, docY = [], []\\n for i in range(len(data)-n_prev):\\n docX.append(data.iloc[i:i+n_prev].as_matrix())\\n docY.append(data.iloc[i+n_prev].as_matrix())\\n alsX = np.array(docX)\\n alsY = np.array(docY)\\n\\n return alsX, alsY\",\n \"def _convert_records_step(self, op: data_algebra.data_ops_types.OperatorPlatform, *, data_map: Dict[str, Any]):\\n if op.node_name != \\\"ConvertRecordsNode\\\":\\n raise TypeError(\\n \\\"op was supposed to be a data_algebra.data_ops.ConvertRecordsNode\\\"\\n )\\n res = self._compose_polars_ops(op.sources[0], data_map=data_map)\\n if isinstance(res, pl.LazyFrame):\\n res = res.collect()\\n res = op.record_map.transform(res, local_data_model=self)\\n if self.use_lazy_eval and (not isinstance(res, pl.LazyFrame)):\\n res = res.lazy()\\n return res\",\n \"def transpose_batch_time(inputs: torch.Tensor) ->torch.Tensor:\\n return inputs.transpose(0, 1)\",\n \"def _load_data(data, n_prev=3):\\n docX, docY = [], []\\n for i in range(len(data)-n_prev):\\n docX.append(data.data.iloc[i:i+n_prev])\\n docY.append(data.response.iloc[i+n_prev]) \\n\\n alsX = np.array(docX)\\n alsY = np.array(docY)\\n return np.matrix(alsX), np.matrix(alsY).T\",\n \"def transpose(self):\\n data = [list(col) for col in zip(*self.data)]\\n return self.__class__(self.n, self.m, data)\",\n \"def individual_collate(batch):\\n\\n data = batch\\n\\n collected_data = defaultdict(list)\\n\\n for i in range(len(list(data))):\\n for k in data[i].keys():\\n collected_data[k].append(data[i][k])\\n\\n for k in collected_data.keys():\\n collected_data[k] = torch.stack(collected_data[k])\\n\\n return collected_data\",\n \"def _load(self, load_dict):\\n for key in list(load_dict.keys()):\\n # We delete keys over time:\\n if key in load_dict:\\n if SparseResult.IDENTIFIER in key:\\n new_key = key.split(SparseResult.IDENTIFIER)[0]\\n matrix = SparseParameter._reconstruct_matrix(load_dict[key])\\n self._data[new_key] = matrix\\n else:\\n self._data[key] = load_dict[key]\",\n \"def loadasem(loads, IBC, neq):\\r\\n RHSG = np.zeros([neq])\\r\\n nl = loads.shape[0]\\r\\n for i in range(nl):\\r\\n il = int(loads[i, 0])\\r\\n ilx = IBC[il, 0]\\r\\n ily = IBC[il, 1]\\r\\n ilT = IBC[il, 2]\\r\\n if ilx != -1:\\r\\n RHSG[ilx] = loads[i, 1]\\r\\n if ily != -1:\\r\\n RHSG[ily] = loads[i, 2]\\r\\n if ilT != -1:\\r\\n RHSG[ilT] = loads[i, 3]\\r\\n return RHSG\",\n \"def load_data():\\n f = gzip.open('mnist.pkl.gz', 'rb')\\n training_data, validation_data, test_data = pickle.load(f, encoding=\\\"latin1\\\")\\n f.close()\\n \\n X_train = [np.reshape(x, (784, 1)) for x in training_data[0]]\\n Y_train = [vectorized_result(y) for y in training_data[1]]\\n \\n X_validation = [np.reshape(x, (784, 1)) for x in validation_data[0]]\\n Y_validation = validation_data[1]\\n \\n X_test = [np.reshape(x, (784, 1)) for x in test_data[0]]\\n Y_test = test_data[1]\\n \\n return (X_train, Y_train, X_validation, Y_validation, X_test, Y_test)\",\n \"def load_as_files(self, lazy=True):\\n # Handle lazy load\\n if lazy:\\n try:\\n questions = read_file_data('questions', self.inputs_dir)\\n answers = read_file_data('answers', self.inputs_dir)\\n questions_vocabs = read_file_data('questions_vocabs', self.inputs_dir)\\n answers_vocabs = read_file_data('answers_vocabs', self.inputs_dir)\\n except Exception as e:\\n print('Failed to lazy load !', e)\\n questions, answers, questions_vocabs, answers_vocabs = self.sub.load_as_raw()\\n save_file_data('questions', questions, self.inputs_dir)\\n save_file_data('answers', answers, self.inputs_dir)\\n save_file_data('questions_vocabs', questions_vocabs, self.inputs_dir)\\n save_file_data('answers_vocabs', answers_vocabs, self.inputs_dir)\\n else:\\n questions, answers, questions_vocabs, answers_vocabs = self.sub.load_as_raw()\\n\\n # It will always use vi as src en as output\\n X_train, X_test, y_train, y_test = train_test_split(questions, answers, test_size=0.2, random_state=42)\\n X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train, test_size=0.25, random_state=42)\\n\\n # Train\\n save_list_to_file(X_train, '{}/train.vi'.format(self.inputs_dir))\\n save_list_to_file(y_train, '{}/train.en'.format(self.inputs_dir))\\n\\n # Valid\\n save_list_to_file(X_valid, '{}/dev.vi'.format(self.inputs_dir))\\n save_list_to_file(y_valid, '{}/dev.en'.format(self.inputs_dir))\\n\\n # Test\\n save_list_to_file(X_test, '{}/test.vi'.format(self.inputs_dir))\\n save_list_to_file(y_test, '{}/test.en'.format(self.inputs_dir))\\n\\n # vocab\\n save_list_to_file(questions_vocabs, '{}/vocab.vi'.format(self.inputs_dir))\\n save_list_to_file(answers_vocabs, '{}/vocab.en'.format(self.inputs_dir))\",\n \"def load_data(self, t):\\n self.ensure_datafiles()\\n datafile = os.path.join(self.data_dir, ALL_DATA[t])\\n data = sio.loadmat(datafile)\\n return data['X'].transpose(3, 0, 1, 2), data['y']\",\n \"def triples(self):\\n return pd.concat((self._load_train(), self._load_valid(), self._load_test()))\",\n \"def transpose_volumes(volumes, slice_direction):\\n if (slice_direction == 'axial'):\\n tr_volumes = volumes\\n elif(slice_direction == 'sagittal'):\\n tr_volumes = [np.transpose(x, (2, 0, 1)) for x in volumes]\\n elif(slice_direction == 'coronal'):\\n tr_volumes = [np.transpose(x, (1, 0, 2)) for x in volumes]\\n else:\\n print('undefined slice direction:', slice_direction)\\n tr_volumes = volumes\\n return tr_volumes\",\n \"def transpose(self, transposition):\\r\\n top_node = self.top_node\\r\\n self.top_node = self.transpose_helper(top_node, transposition)\\r\\n int(self.top_node.split('|')[0][1::].strip('()').split(', ')[0])\\r\\n self.run_clean_up()\",\n \"def load(self):\\n self.word2vec, self.img2sentence, self.word_freq, self.num_words, self.word2idx, self.idx2word = pickle.load(open(self.save_file, 'rb'))\",\n \"def test_unstack3():\\n x = np.arange(1, 49).reshape((4, 3, 2, 2)).astype(np.float64)\\n axis = 1\\n x_tensor = paddle.to_tensor(x)\\n out_list = paddle.unstack(x_tensor, axis=axis)\\n length = len(out_list)\\n for i in range(length):\\n ept = x[:, i, :, :]\\n npt.assert_allclose(out_list[i].numpy(), ept)\",\n \"def imprimir_serializado(self, tipo_tag, tag, transpose, only_buffer,\\n extra_data):\\n self._info(\\\"imprimir_serializado\\\")\\n try:\\n self.controller.imprimir_serializado(tipo_tag, tag, transpose,\\n only_buffer, extra_data)\\n except Exception as exc:\\n # Agarramos todos los errores de impresión que no hayamos agarrrado\\n self.error_impresion()\\n self.logger.exception(exc)\",\n \"def transpose(self):\\n return self._transpose\",\n \"def _ixs(self, i, axis=0):\\n result = super()._ixs(i, axis=axis)\\n\\n # Override columns\\n if axis == 0:\\n if isinstance(i, slice):\\n return self[i]\\n else:\\n label = self.index[i]\\n if isinstance(label, Index):\\n # a location index by definition\\n result = self.take(i, axis=axis)\\n copy = True\\n else:\\n new_values = self._data.fast_xs(i)\\n\\n # if we are a copy, mark as such\\n copy = (\\n isinstance(new_values, np.ndarray) and new_values.base is None\\n )\\n result = self._constructor_sliced(\\n new_values,\\n index=self.columns,\\n name=self.index[i],\\n dtype=new_values.dtype,\\n au_columns=self.au_columns,\\n emotion_columns=self.emotion_columns,\\n facebox_columns=self.facebox_columns,\\n landmark_columns=self.landmark_columns,\\n facepose_columns=self.facepose_columns,\\n gaze_columns=self.gaze_columns,\\n time_columns=self.time_columns,\\n design_columns=self.design_columns,\\n filename=self.filename,\\n sampling_freq=self.sampling_freq,\\n detector=self.detector,\\n features=self.features,\\n sessions=self.sessions,\\n )\\n result._set_is_copy(self, copy=copy)\\n return result\\n\\n else:\\n \\\"\\\"\\\"\\n Notes\\n -----\\n If slice passed, the resulting data will be a view\\n \\\"\\\"\\\"\\n\\n label = self.columns[i]\\n if isinstance(i, slice):\\n # need to return view\\n lab_slice = slice(label[0], label[-1])\\n return self.loc[:, lab_slice]\\n else:\\n if isinstance(label, Index):\\n return self._take(i, axis=1, convert=True)\\n\\n index_len = len(self.index)\\n\\n # if the values returned are not the same length\\n # as the index (iow a not found value), iget returns\\n # a 0-len ndarray. This is effectively catching\\n # a numpy error (as numpy should really raise)\\n values = self._data.iget(i)\\n\\n if index_len and not len(values):\\n values = np.array([np.nan] * index_len, dtype=object)\\n result = self._constructor_sliced(\\n values,\\n index=self.index,\\n name=label,\\n fastpath=True,\\n au_columns=self.au_columns,\\n emotion_columns=self.emotion_columns,\\n facebox_columns=self.facebox_columns,\\n landmark_columns=self.landmark_columns,\\n facepose_columns=self.facepose_columns,\\n gaze_columns=self.gaze_columns,\\n time_columns=self.time_columns,\\n design_columns=self.design_columns,\\n filename=self.filename,\\n sampling_freq=self.sampling_freq,\\n detector=self.detector,\\n features=self.features,\\n sessions=self.sessions,\\n )\\n\\n # this is a cached value, mark it so\\n result._set_as_cached(label, self)\\n return result\",\n \"def array(self):\\n aa = list(map(np.asarray, self.loader_array.flat))\\n return np.stack(aa, axis=0).reshape(self.output_shape)\",\n \"def collate_fn(self, batch):\\n images = list()\\n targets = list()\\n\\n for b in batch:\\n images.append(b[0])\\n targets.append(b[1])\\n\\n # images = torch.stack(images, dim=0)\\n\\n return images, targets # tensor (N, 3, 300, 300), 3 lists of N tensors each\",\n \"def _assemble_tiles(i, n, tile, tsincr_g, output_dir, outtype):\\n # pylint: disable=too-many-arguments\\n tsincr_file = os.path.join(output_dir, '{}_{}.npy'.format(outtype, n))\\n tsincr = np.load(file=tsincr_file)\\n tsincr_g[tile.top_left_y:tile.bottom_right_y, tile.top_left_x:tile.bottom_right_x] = tsincr[:, :, i]\",\n \"def convert_transpose(g, op, block):\\n\\n perm = op.attr(\\\"axis\\\")\\n out = _op.transpose(g.get_node(op.input(\\\"X\\\")[0]), axes=perm)\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def convert_train(ndata, ndim):\\r\\n print ('Converting training data ... ')\\r\\n x = np.zeros([ndata, ndim])\\r\\n y = np.zeros([ndata])\\r\\n \\r\\n for i in range(0, len(flist) - 2):\\r\\n batchn = filepath + flist[i]\\r\\n temp = read(batchn)\\r\\n x[i * 10000:(i + 1) * 10000] = temp['data']\\r\\n y[i * 10000:(i + 1) * 10000] = temp['labels']\\r\\n \\\"\\\"\\\"\\r\\n i=0\\r\\n batchn = filepath + flist[i]\\r\\n\\r\\n temp = read(batchn)\\r\\n\\r\\n x[i * 10000:(i + 1) * 10000] = temp['data']\\r\\n\\r\\n y[i * 10000:(i + 1) * 10000] = temp['labels']\\r\\n \\\"\\\"\\\"\\r\\n return x, y\",\n \"def split_and_load(arrs, _ctxs):\\n # TODO Replace split_array() with gluon.utils.split_data() once targeting MXNet 1.7\\n assert isinstance(arrs, (list, tuple))\\n # split and load\\n loaded_arrs = [[i.as_in_context(ctx) for i, ctx in zip(split_array(arr, len(_ctxs)), _ctxs)]\\n for arr in arrs]\\n return zip(*loaded_arrs)\",\n \"def reformat(dataset):\\n x = dataset[:, 1] \\n x = np.stack(x) # reshape to (n, mel bands, timesteps)\\n x = np.expand_dims(np.moveaxis(x, 1, -1), axis=3) # reformat x to (n, timesteps, mel bands, 1) \\n y = dataset[:, 2] \\n y = np.moveaxis(np.stack(y), 1, -1) # reformat y to (n, timesteps, 8)\\n return x, y\",\n \"def flatten(file_name):\\n dataset = pickle.load(open(file_name, 'rb'))\\n train_data = dataset['train']\\n test_data = dataset['test']\\n\\n train_data = [y for x in train_data for y in x]\\n test_data = [y for x in test_data for y in x]\\n\\n train_data=generate_binary_vectors(train_data,False)\\n test_data=generate_binary_vectors(test_data,False)\\n\\n return train_data, test_data\",\n \"def test_unstack2():\\n x = np.arange(1, 25).reshape((4, 2, 3)).astype(np.float32)\\n axis = 2\\n x_tensor = paddle.to_tensor(x)\\n out_list = paddle.unstack(x_tensor, axis=axis)\\n length = len(out_list)\\n for i in range(length):\\n ept = x[:, :, i]\\n npt.assert_allclose(out_list[i].numpy(), ept)\",\n \"def _load_wt(self, x):\\n W = x[:self.dimY*self.dimX].reshape(self.dimY,self.dimX) \\n W = W.transpose() # Coz W is stored in such way\\n # print(W)\\n T = x[self.dimY*self.dimX:].reshape(self.dimY,self.dimY).transpose() \\n return W, T\",\n \"def transpose(seqseq):\\n return zip(*seqseq)\",\n \"def restore(self, ids):\\n with self._db_connection(transaction=True) as transaction:\\n for id_ in ids:\\n transaction.restore_dataset(id_)\",\n \"def convert_unstack(g, op, block):\\n\\n x = g.get_node(op.input(\\\"X\\\")[0])\\n axis = op.attr(\\\"axis\\\")\\n indices_or_sections = len(op.output(\\\"Y\\\"))\\n outs = _op.split(x, indices_or_sections=indices_or_sections, axis=axis)\\n for i, out in enumerate(outs):\\n out = _op.squeeze(out, axis=axis)\\n g.add_node(op.output(\\\"Y\\\")[i], out)\",\n \"def T(self):\\n return Op('transpose', self)\",\n \"def _load_a_couple0(self, path):\\n assert(self._initialisation)\\n X = pd.read_hdf(path[0], key='s')\\n Y = np.load(path[1])\\n return X , Y\",\n \"def transpose_volumes(volumes, slice_direction):\\n if (slice_direction == 'axial'):\\n tr_volumes = volumes\\n elif(slice_direction == 'sagittal'):\\n if isinstance(volumes, list) or len(volumes.shape) > 3:\\n tr_volumes = [np.transpose(x, (2, 0, 1)) for x in volumes]\\n else:\\n tr_volumes = np.transpose(volumes, (2, 0, 1))\\n elif(slice_direction == 'coronal'):\\n if isinstance(volumes, list) or len(volumes.shape) > 3:\\n tr_volumes = [np.transpose(x, (1, 0, 2)) for x in volumes]\\n else:\\n tr_volumes = np.transpose(volumes, (1, 0, 2))\\n else:\\n print('undefined slice direction:', slice_direction)\\n tr_volumes = volumes\\n return tr_volumes\",\n \"def load(self, i: int) -> np.ndarray:\\n raise NotImplementedError(\\\"Do not call load from BaseLoader\\\")\",\n \"def setup_transposed_data(self, data: List[Dict[str, Any]]):\\n output = []\\n open = []\\n low = []\\n high = []\\n volume = []\\n for dat in data:\\n open.append(dat[\\\"open\\\"])\\n low.append(dat[\\\"low\\\"])\\n high.append(dat[\\\"high\\\"])\\n volume.append(dat[\\\"volume\\\"])\\n output.append(dat[\\\"close\\\"])\\n input = [open, low, high, volume]\\n return input, output\",\n \"def transpose(x: torch.Tensor, dims):\\n _dims = list(dims)\\n for i in range(len(_dims)):\\n if _dims[i] != i:\\n x = x.transpose(i, _dims[i])\\n j = _dims.index(i)\\n _dims[i], _dims[j] = i, _dims[i]\\n return x\",\n \"def Zip(datasets):\\n return tf.data.Dataset.zip(datasets)\",\n \"def load_X():\\n x1 = np.asarray([-1, -1, 1, -1, 1, -1, -1, 1]).reshape((1, 8))\\n x2 = np.asarray([-1, -1, -1, -1, -1, 1, -1, -1]).reshape((1, 8))\\n x3 = np.asarray([-1, 1, 1, -1, -1, 1, -1, 1]).reshape((1, 8))\\n X = np.vstack([x1, x2, x3])\\n\\n return X\",\n \"def transpose(self, *args, **kwargs):\\n return _image.image_transpose(self, *args, **kwargs)\",\n \"def load(self, record: api.Record) -> api.DataRecord:\\n\\n def _index_dict_to_arr(d, keys):\\n if isinstance(keys, list):\\n return np.array([d[k] for k in keys])\\n else:\\n return np.array(d[keys])\\n\\n X = {k: _index_dict_to_arr(record, v) for k, v in self.inputs.items()}\\n if self.mode == api.RecordMode.TRAIN or self.mode == api.RecordMode.VALIDATION:\\n y = {k: _index_dict_to_arr(record, v) for k, v in self.outputs.items()}\\n if self.sample_weights is not None:\\n w = {k: np.array(record[v]) for k, v in self.sample_weights.items()}\\n return (X, y, w)\\n else:\\n return (X, y)\\n else:\\n return (X,)\",\n \"def load_chunks(self):\\n for key, array in self.chunks.items():\\n loaded_array = np.asarray(array)\\n self.chunks[key] = loaded_array\",\n \"def test_unstack():\\n x = np.arange(1, 13).reshape((3, 2, 2)).astype(np.int32)\\n axis = 0\\n x_tensor = paddle.to_tensor(x)\\n out_list = paddle.unstack(x_tensor, axis=axis)\\n length = len(out_list)\\n for i in range(length):\\n ept = x[i, :, :]\\n npt.assert_allclose(out_list[i].numpy(), ept)\",\n \"def load_data(self):\",\n \"def retrieval_collate(data):\\n # separate source and target sequences\\n t2i_batch, i2t_batch = list(zip(*data))\\n\\n # t2i\\n def generate_inputs(_batch):\\n sent, att_feats, img_masks, box_feats, obj_labels, pos_labels, img_ids, langs = zip(\\n *_batch)\\n # sent = np.array(sent)\\n _sent = []\\n _pos_labels = []\\n _img_ids = []\\n _langs = []\\n for s, p, i, l in zip(sent, pos_labels, img_ids, langs):\\n _sent.extend(s)\\n _pos_labels.extend(p)\\n _img_ids.extend(i)\\n _langs.extend(l)\\n pos_labels = _pos_labels\\n img_ids = _img_ids\\n\\n x_img = torch.stack(att_feats, dim=0)\\n img_loc = torch.stack(box_feats, dim=0)\\n x_img_mask = torch.stack(img_masks, dim=0)\\n x_obj_labels = torch.stack(obj_labels, dim=0)\\n\\n x_img = x_img.view([-1] + list(tuple(x_img.size()[2:])))\\n img_loc = img_loc.view([-1] + list(tuple(img_loc.size()[2:])))\\n x_img_mask = x_img_mask.view([-1] + list(tuple(x_img_mask.size()[2:])))\\n x_obj_labels = x_obj_labels.view([-1] + list(tuple(x_obj_labels.size()[2:])))\\n\\n _inputs = [batch_sentences(_sent, _langs),\\n [x_img,\\n x_img_mask,\\n img_loc,\\n x_obj_labels,\\n pos_labels,\\n img_ids] # google_replace\\n ]\\n return _inputs\\n\\n _t2i_out = generate_inputs(t2i_batch) if t2i_batch is not None else None\\n _i2t_out = generate_inputs(i2t_batch) if i2t_batch is not None else None\\n all_return_results = [_t2i_out, _i2t_out]\\n return all_return_results\",\n \"def sinterstore(self, dest, keys, *args):\\r\\n keys = list_or_args('sinterstore', keys, args)\\r\\n return self.format_inline('SINTERSTORE', dest, *keys)\",\n \"def imed_collate(batch):\\n error_msg = \\\"batch must contain tensors, numbers, dicts or lists; found {}\\\"\\n elem_type = type(batch[0])\\n if torch.is_tensor(batch[0]):\\n stacked = torch.stack(batch, 0)\\n return stacked\\n elif elem_type.__module__ == 'numpy' and elem_type.__name__ != 'str_' \\\\\\n and elem_type.__name__ != 'string_':\\n elem = batch[0]\\n if elem_type.__name__ == 'ndarray':\\n # array of string classes and object\\n if re.search('[SaUO]', elem.dtype.str) is not None:\\n raise TypeError(error_msg.format(elem.dtype))\\n return torch.stack([torch.from_numpy(b) for b in batch], 0)\\n if elem.shape == (): # scalars\\n py_type = float if elem.dtype.name.startswith('float') else int\\n return __numpy_type_map[elem.dtype.name](list(map(py_type, batch)))\\n elif isinstance(batch[0], int_classes):\\n return torch.LongTensor(batch)\\n elif isinstance(batch[0], float):\\n return torch.DoubleTensor(batch)\\n elif isinstance(batch[0], string_classes):\\n return batch\\n elif isinstance(batch[0], collections.abc.Mapping):\\n return {key: imed_collate([d[key] for d in batch]) for key in batch[0]}\\n elif isinstance(batch[0], collections.abc.Sequence):\\n return [imed_collate(samples) for samples in batch]\\n\\n return batch\",\n \"def __data_generation(self, folder_id, file_id, el_ids):\\n self.reload(folder_id, file_id)\\n X = self.X[el_ids]\\n Y = self.apply_preprocess_y(self.Y[:,:,:,el_ids])\\n Y = np.rollaxis(Y,-1) #6,72,72,BS\\n Y = Y.swapaxes(-2,-1)\\n return X,Y\",\n \"def dataset_to_tensors(dataset):\\r\\n tensor_num = len(dataset[0])\\r\\n tensors = [torch.LongTensor([sample[i] for sample in dataset]) for i in range(tensor_num)]\\r\\n return tensors\",\n \"def temporally_align_data_interfaces(self):\\n pass\",\n \"def load_data(): \\n\\tdf = pandas.read_csv('data/iris.data', header=None)\\n\\ty = df.iloc[0:df.shape[0], 4].values\\n\\ty = np.where(y == 'Iris-setosa', 0, y)\\n\\ty = np.where(y == 'Iris-versicolor', 1, y)\\n\\ty = np.where(y == 'Iris-virginica', 2, y)\\n\\tx = df.iloc[0:df.shape[0], 0:4].values\\n\\tx = tuple(x)\\n\\ty = tuple(y)\\n\\ttraining_inputs = x[0:40] + x[50:90] + x[100:140]\\n\\ttraining_results = y[0:40] + y[50:90] + y[100:140]\\n\\ttraining_data = (training_inputs, training_results)\\n\\ttest_inputs = x[40:50] + x[90:100] + x[140:150]\\n\\ttest_results = y[40:50] + y[90:1000] + y[140:150]\\n\\ttest_data = (test_inputs, test_results)\\n\\treturn (training_data, test_data)\",\n \"def collate_fn(self, batch):\\n images = list()\\n boxes = list()\\n labels = list()\\n difficulties = list()\\n\\n for b in batch:\\n images.append(b[0])\\n boxes.append(b[1])\\n labels.append(b[2])\\n difficulties.append(b[3])\\n\\n images = torch.stack(images, dim=0)\\n\\n return images, boxes, labels, difficulties # tensor (N, 3, 300, 300), 3 lists of N tensors each\",\n \"def T(self):\\n return F.Transpose.apply(self)\",\n \"def test_transpose():\\n x = np.array([\\n [1, 2],\\n [3, 4]\\n ])\\n y = np.array([\\n [5, 6],\\n [7, 8]\\n ])\\n z = np.dstack([x, y])\\n return z, z.transpose(1, 0, 2)\",\n \"def to_ir(self):\",\n \"def test_unstack1():\\n x = np.arange(1, 25).reshape((4, 2, 3)).astype(np.float32)\\n axis = -1\\n x_tensor = paddle.to_tensor(x)\\n out_list = paddle.unstack(x_tensor, axis=axis)\\n length = len(out_list)\\n for i in range(length):\\n ept = x[:, :, i]\\n npt.assert_allclose(out_list[i].numpy(), ept)\",\n \"def __data_generation(self, folder_id, file_id, el_ids):\\n self.reload(folder_id, file_id)\\n X = np.array(self.X.iloc[el_ids]).reshape(self.batch_size, len(self.used_variables), self.lev)\\n Y = self.Y[:,:,:,el_ids]\\n return X,Y\",\n \"def _read_interpops(self, sheet) -> None:\\n tables, start_rows = read_tables(sheet)\\n assert len(tables) % 3 == 0, \\\"There should be 3 subtables for every transfer\\\"\\n self.interpops = []\\n for i in range(0, len(tables), 3):\\n self.interpops.append(TimeDependentConnections.from_tables(tables[i : i + 3], \\\"interaction\\\"))\\n return\",\n \"def transpose(self):\\n trans = Matrix(self.ncols,self.nrows)\\n for i in range(self.nrows):\\n for j in range(self.ncols):\\n trans.matrix[j][i] = self.matrix[i][j]\\n return trans\",\n \"def _transpose(h_lines: List[Line]) -> List[Line]:\\n\\n return [Line([line.get_field(i) for line in h_lines]) for i in range(SIZE)]\",\n \"def transpose():\\n\\tdata = request.get_json()\\n\\tm=int(data[\\\"m\\\"])\\n\\tn=int(data[\\\"n\\\"])\\n\\tfor i in range (0,m):\\n\\t\\tfor j in range(0,n):\\n\\t\\t\\tdata[\\\"Matrix\\\"][i][j]=data[\\\"Matrix\\\"][i][j]*100\\n\\treturn json.dumps(data[\\\"Matrix\\\"])\\n\\t\\n\\treturn json.dumps(data[\\\"Matrix\\\"])\",\n \"def transpose(tensor):\\n raise NotImplementedError\",\n \"def load_all(digit):\\n\\n tests = load(digit, type_str='test')\\n trains = load(digit, type_str='train') # choo choo\\n \\n return numpy.concatenate((tests, trains), axis=0)\",\n \"def pack(self):\\n if self.stack:\\n # Should be a straight forward concatenation\\n packed = torch.cat(self.data, dim=0)\\n else:\\n # Need to account for padding values\\n from netharn.data.collate import padded_collate\\n inbatch = list(ub.flatten(self.data))\\n packed = padded_collate(inbatch, fill_value=self.padding_value)\\n return packed\",\n \"def slide_collate(data):\\n # separate source and target sequences\\n sent, att_feats, img_masks, box_feats, img_ids,cur_label = list(zip(*data))\\n\\n # t2i\\n def generate_inputs():\\n # sent = np.array(sent)\\n\\n _sent = []\\n _img_ids = []\\n _labels = []\\n for s, i, p in zip(sent, img_ids, cur_label):\\n _sent.extend(s)\\n _img_ids.extend(i)\\n _labels.extend(p)\\n\\n\\n x_img = torch.stack(att_feats, dim=0)\\n img_loc = torch.stack(box_feats, dim=0)\\n x_img_mask = torch.stack(img_masks, dim=0)\\n\\n x_img = x_img.view([-1] + list(tuple(x_img.size()[2:])))\\n img_loc = img_loc.view([-1] + list(tuple(img_loc.size()[2:])))\\n x_img_mask = x_img_mask.view([-1] + list(tuple(x_img_mask.size()[2:])))\\n\\n _inputs = [batch_sentences(_sent),\\n [x_img,\\n x_img_mask,\\n img_loc,\\n _img_ids],\\n _labels\\n ]\\n return _inputs\\n\\n all_return_results = generate_inputs()\\n return all_return_results\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5811776","0.57074726","0.5681151","0.5640245","0.55777746","0.5351398","0.5351398","0.52928823","0.5287192","0.5227838","0.52135694","0.5213067","0.5190803","0.5118121","0.5108729","0.5093582","0.5092675","0.50697315","0.50460935","0.50371075","0.5006182","0.50004834","0.4999462","0.49900642","0.49856082","0.4943599","0.49363303","0.48820063","0.48805973","0.48768356","0.4858382","0.48516113","0.48445538","0.48323405","0.4831105","0.47996712","0.47733393","0.47662818","0.4763852","0.47526124","0.47401434","0.4735197","0.47241178","0.47054166","0.4703393","0.47008452","0.46759877","0.4675801","0.4675073","0.4672693","0.4670535","0.4652677","0.4650594","0.46482545","0.46468157","0.46451035","0.46432117","0.46418804","0.46396878","0.46296945","0.46270958","0.46221834","0.46188265","0.46169755","0.46158963","0.46145472","0.46085584","0.4595848","0.45875394","0.45796677","0.45791546","0.45772403","0.4572503","0.45674986","0.4565756","0.45629054","0.455923","0.4549358","0.45463595","0.4544769","0.45391655","0.45364463","0.45322412","0.45213202","0.45205614","0.4519393","0.45182067","0.451818","0.45171517","0.45162597","0.45138213","0.45031765","0.4502207","0.44985792","0.44943848","0.44929075","0.44885767","0.44860822","0.44785568","0.44784552"],"string":"[\n \"0.5811776\",\n \"0.57074726\",\n \"0.5681151\",\n \"0.5640245\",\n \"0.55777746\",\n \"0.5351398\",\n \"0.5351398\",\n \"0.52928823\",\n \"0.5287192\",\n \"0.5227838\",\n \"0.52135694\",\n \"0.5213067\",\n \"0.5190803\",\n \"0.5118121\",\n \"0.5108729\",\n \"0.5093582\",\n \"0.5092675\",\n \"0.50697315\",\n \"0.50460935\",\n \"0.50371075\",\n \"0.5006182\",\n \"0.50004834\",\n \"0.4999462\",\n \"0.49900642\",\n \"0.49856082\",\n \"0.4943599\",\n \"0.49363303\",\n \"0.48820063\",\n \"0.48805973\",\n \"0.48768356\",\n \"0.4858382\",\n \"0.48516113\",\n \"0.48445538\",\n \"0.48323405\",\n \"0.4831105\",\n \"0.47996712\",\n \"0.47733393\",\n \"0.47662818\",\n \"0.4763852\",\n \"0.47526124\",\n \"0.47401434\",\n \"0.4735197\",\n \"0.47241178\",\n \"0.47054166\",\n \"0.4703393\",\n \"0.47008452\",\n \"0.46759877\",\n \"0.4675801\",\n \"0.4675073\",\n \"0.4672693\",\n \"0.4670535\",\n \"0.4652677\",\n \"0.4650594\",\n \"0.46482545\",\n \"0.46468157\",\n \"0.46451035\",\n \"0.46432117\",\n \"0.46418804\",\n \"0.46396878\",\n \"0.46296945\",\n \"0.46270958\",\n \"0.46221834\",\n \"0.46188265\",\n \"0.46169755\",\n \"0.46158963\",\n \"0.46145472\",\n \"0.46085584\",\n \"0.4595848\",\n \"0.45875394\",\n \"0.45796677\",\n \"0.45791546\",\n \"0.45772403\",\n \"0.4572503\",\n \"0.45674986\",\n \"0.4565756\",\n \"0.45629054\",\n \"0.455923\",\n \"0.4549358\",\n \"0.45463595\",\n \"0.4544769\",\n \"0.45391655\",\n \"0.45364463\",\n \"0.45322412\",\n \"0.45213202\",\n \"0.45205614\",\n \"0.4519393\",\n \"0.45182067\",\n \"0.451818\",\n \"0.45171517\",\n \"0.45162597\",\n \"0.45138213\",\n \"0.45031765\",\n \"0.4502207\",\n \"0.44985792\",\n \"0.44943848\",\n \"0.44929075\",\n \"0.44885767\",\n \"0.44860822\",\n \"0.44785568\",\n \"0.44784552\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.684812"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":87189,"cells":{"query":{"kind":"string","value":"Compute the distribution function at the equilibrium with the value on the border."},"document":{"kind":"string","value":"def prepare_rhs(self, simulation):\n\n nv = simulation.container.nv\n sorder = simulation.container.sorder\n nspace = [1] * (len(sorder) - 1)\n v = self.stencil.get_all_velocities()\n\n gpu_support = simulation.container.gpu_support\n\n for key, value in self.value_bc.items():\n if value is not None:\n indices = np.where(self.ilabel == key)\n # TODO: check the index in sorder to be the most contiguous\n nspace[0] = indices[0].size\n k = self.istore[0, indices]\n\n s = 1 - self.distance[indices]\n coords = tuple()\n for i in range(simulation.domain.dim):\n x = simulation.domain.coords_halo[i][self.istore[i + 1, indices]]\n x += s * v[k, i] * simulation.domain.dx\n x = x.ravel()\n for j in range(\n 1, simulation.domain.dim\n ): # pylint: disable=unused-variable\n x = x[:, np.newaxis]\n coords += (x,)\n\n m = Array(nv, nspace, 0, sorder, gpu_support=gpu_support)\n m.set_conserved_moments(simulation.scheme.consm)\n\n f = Array(nv, nspace, 0, sorder, gpu_support=gpu_support)\n f.set_conserved_moments(simulation.scheme.consm)\n\n args = coords\n if isinstance(value, types.FunctionType):\n func = value\n elif isinstance(value, tuple):\n func = value[0]\n args += value[1]\n\n if self.time_bc[key]:\n func(f, m, 0, *args)\n else:\n func(f, m, *args)\n\n simulation.equilibrium(m)\n simulation.m2f(m, f)\n\n if self.generator.backend.upper() == \"LOOPY\":\n f.array_cpu[...] = f.array.get()\n\n self.feq[:, indices[0]] = f.swaparray.reshape((nv, indices[0].size))\n\n if self.time_bc[key]:\n self.func.append(func)\n self.args.append(args)\n self.f.append(f)\n self.m.append(m)\n self.indices.append(indices[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 erfc(x):\n return 0.0","def gaussed_value(self):\n from random import gauss\n return sorted([0, int(gauss(self.value, self.sigma)), \\\n (self.size*8)-1])[1]","def normalizefunction(self , values):\n maxv = np.max(values)\n minv = np.min(values)\n def f(x):\n return (x - minv)/(maxv-minv)\n return f","def get_value(self) -> float:\n return random.gauss(self._mu, self._sigma)","def fluence(self, range_x):\n time_step = np.diff(range_x)\n val_square = np.square(np.abs(self(range_x)))\n res = np.sum(np.array(val_square[:-1] * time_step))\n res = res/(range_x[-1] - range_x[0])\n return res","def fdq1(f, x, h=1e-5):\n return (f(x+h) - f(x))/h\n \n raise NotImplementedError(\"Problem 2 Incomplete\")","def f(a):\n b = a * 2\n while b.norm().asscalar() < 1000:\n b = b * 2\n if b.sum().asscalar() > 0:\n c = b\n else:\n c = 100 * b\n return c","def bdq1(f, x, h=1e-5):\n return (f(x)-f(x-h))/h\n raise NotImplementedError(\"Problem 2 Incomplete\")","def bisection(f, fu, point_a, point_b, point_c, point_d, lower_bound, upper_bound, length):\n n = 1\n theta = 0\n a = lower_bound\n b = upper_bound\n while n <= 100:\n theta = (a + b) / 2.0\n if -1e-6 < f(fu(point_a, point_b, point_c, theta), point_d) - length < 1e-6:\n # print 'Residual', f(fu(point_a, point_b, point_c, theta), point_d) - length\n # print 'iteration', n\n return theta\n else:\n n = n + 1\n if f(fu(point_a, point_b, point_c, theta), point_d) - length > 0:\n b = theta\n else:\n a = theta\n\n print 'failedtheta', theta, 'Residual', f(fu(point_a, point_b, point_c, theta), point_d) - length\n print 'iteration', n\n return False","def fn(val):\n if val < x: return min(2*val-1, 2*(x-val))\n k = int(log(val)//log(x))\n ans = k + fn(val - x**k)\n if x**(k+1) < 2*val: \n ans = min(ans, k + 1 + fn(x**(k+1) - val))\n return ans","def fom(self):\n return self.table[1, 0] / (self.table[0, 0] + self.table[1, 0])","def exprenyi(alpha, sigma, top, bottom):\n return siquad(getdensity(alpha, sigma, top, bottom),\n -np.infty, np.infty)[0]","def integrate_gausskronrod(f, a, b, args=()):\n\n assert b > a\n mid = 0.5*(b+a)\n dx = 0.5*(b-a)\n zi = mid+gausskronrod_nodes*dx\n integrand = f(zi)\n integral_G7 = np.sum(integrand[:7]*gauss_weights)\n integral_K15 = np.sum(integrand*kronrod_weights)\n\n error = (200*abs(integral_G7-integral_K15))**1.5\n\n return integral_K15*dx, dx*error","def fn(i, j):\n if i == 0 and j == 0: return grid[i][j]\n if i < 0 or j < 0: return float(\"inf\")\n return grid[i][j] + min(fn(i-1, j), fn(i, j-1))","def fn(i, j):\n if i == 0 and j == 0: return grid[i][j]\n if i < 0 or j < 0: return float(\"inf\")\n return grid[i][j] + min(fn(i-1, j), fn(i, j-1))","def F(x):\n return math.exp(-0.5 * (x ** 2))","def compute_fk(self, sigma, sigma_des, C, offset):\n if sigma >= sigma_des:\n # push robot away\n f = -((sigma - sigma_des) ** 2)/C + offset\n elif sigma < sigma_des:\n # pull robot in\n f = ((sigma - sigma_des) ** 2)/C + offset\n else:\n f = 0\n return f","def density(temp,pres):\n g_p = liq_g(0,1,temp,pres)\n dliq = g_p**(-1)\n return dliq","def norm_cdf(self, x):\n k = 1.0/(1.0+0.2316419*x)\n k_sum = k * (0.319381530 + k * (-0.356563782 + \\\n k * (1.781477937 + k * (-1.821255978 + 1.330274429 * k))))\n \n if x >= 0.0:\n return (1.0 - (1.0 / ((2 * pi)**0.5)) * exp(-0.5 * x * x) * k_sum)\n else:\n return 1.0 - self.norm_cdf(-x)","def real_value(val):\n\t\treturn round(val/100*sum(euros), 1)","def radial_distribution_function(alpha):\n\n ALPHA_MAX = 0.59999\n\n ALPHA0 =0.6\n\n numpy.where(alpha > ALPHA_MAX, ALPHA_MAX, alpha)\n\n return 1.0/(1.0-(alpha/ALPHA0)**(1.0/3.0))","def gauss_wp(self, delta, x0=0):\n constant = (delta/np.pi)**(1/4) * (1.+0.j) \n wp = constant * np.exp((-0.5 * delta * np.square(self.grid_x - x0)))\n return wp","def density(self, arg):\n return self.gb2_density(np.exp(arg)) * np.exp(arg)","def _analytical_cdf_term(self, j, t):\n\n try:\n\n return ((1 - np.cos(j * np.pi)) / j) * np.sin(j * np.pi * self.x0 / self.L) * \\\n np.exp(-(j * np.pi * self.sigma / self.L) ** 2 * t)\n\n except FloatingPointError: # at large t, the exponential term gets REALLY small causing an underflow\n return 0","def g(f, x: float):\n return lambda x: f(x + f(x)) / f(x) - 1","def apply(cls, x):\n return np.maximum(0, np.minimum(1, 0.2*x + 0.5))","def calculate(i: int, j: int) -> float:\n if self.ca[i, j] > -1.0:\n return self.ca[i, j]\n\n d = self.dist_func(p[i], q[j])\n if i == 0 and j == 0:\n self.ca[i, j] = d\n elif i > 0 and j == 0:\n self.ca[i, j] = max(calculate(i - 1, 0), d)\n elif i == 0 and j > 0:\n self.ca[i, j] = max(calculate(0, j - 1), d)\n elif i > 0 and j > 0:\n self.ca[i, j] = max(\n min(\n calculate(i - 1, j),\n calculate(i - 1, j - 1),\n calculate(i, j - 1),\n ),\n d,\n )\n else:\n self.ca[i, j] = np.infty\n return self.ca[i, j]","def frobenius(self, value):\n return sum(self.hadamard(value))","def erf(x):\n return 0.0","def calc(self,newValue):\n idx=np.searchsorted(self.quantiles, newValue, side=\"left\")\n if idx>=self.n-1:\n return idx/self.n\n if np.abs(newValue - self.quantiles[idx-1]) < np.abs(newValue - self.quantiles[idx]):\n return (idx-1)/self.n\n else:\n return idx/self.n","def f(x):\n\treturn (sc.log(x**2+5)*sc.cos(0.8*x)+3.5*x)/(sc.e**(x/10))","def weibull(self, x):\n return (self.k_alp[0]/self.k_alp[1])*(math.pow(x/self.k_alp[1],(self.k_alp[0]-1))) * \\\n np.exp(-1*math.pow(x/self.k_alp[1],self.k_alp[0]))","def eo_numerical(th):\n res = integrate.dblquad(gaussian_func_2dim_extra, th, np.inf, lambda x: th, lambda x: np.inf)\n return res[0]","def fvec_callable(self, values):\n\n all_sigmas_normalized, _ = self.get_normalized_sigmas(values)\n f = flex.double()\n for i, bin in enumerate(self.bins):\n binned_normalized_sigmas = all_sigmas_normalized.select(bin)\n n = len(binned_normalized_sigmas)\n if n == 0:\n f.append(0)\n continue\n # functional is weight * (1-rms(normalized_sigmas))^s summed over all intensitiy bins\n f.append(1-math.sqrt(flex.mean(binned_normalized_sigmas*binned_normalized_sigmas)))\n\n if self.scaler.params.raw_data.error_models.sdfac_refine.plot_refinement_steps:\n all_sigmas_normalized = all_sigmas_normalized.select(all_sigmas_normalized != 0)\n print(self.modeler.normal_probability_plot(all_sigmas_normalized, (-0.5, 0.5), plot = True))\n return f","def DDG(self, n, e, r, f):\n pre = (-e[:, None] + np.divide.outer((n - 1), r))**2\n pre -= np.divide.outer((n - 1), r**2)\n return pre*f","def ecdf(x0, w=None):\n n = len(x0)\n\n if w is None:\n w = np.ones(n) / n\n else:\n w = w / np.sum(w)\n p = np.cumsum(np.r_[[0], w])[:-1]\n # p = np.linspace(0, 1, n + 1)[:-1]\n\n x = np.sort(x0)\n return p, x","def _compute_f(self, p, dh, dv):\n return dh / (self.beta * p * dv)","def fun_gauss(p,r):\n return p[1] * np.exp(-((r/p[0])**2))","def dfr(self):\n return self.table[1, 0] / (self.table[1, 0] + self.table[1, 1])","def e(self):\n if self._e is None:\n # self._e = self.distributions.uniform(0.3,0.33)\n # return self._e\n # max is set by q but also limited by users choice of e_max.\n res_a = 29.9*((self.j[0]/self.k[0])**(2/3))\n q = self.distributions.truncated_normal(self.q_c, self.q_w, res_a*(1-0.8), res_a*(1-0.001))\n self._e = 1 - q/res_a\n return self._e","def value(a, y):\n\t\treturn 0.5*np.linalg.norm(a-y)**2","def upper_bound(self) -> float:\n ...","def numerical_gradient(f, x: np.ndarray):\n h = 1e-4\n grad = np.zeros_like(x)\n for i in range(x.size):\n tmp_val = x.flat[i]\n x.flat[i] = tmp_val + h\n fxh1 = f(x)\n\n x.flat[i] = tmp_val - h\n fxh2 = f(x)\n grad.flat[i] = (fxh1 - fxh2) / (2 * h)\n x.flat[i] = tmp_val\n return grad","def update(self, function_values, es, bounds=None):\r\n if bounds is None:\r\n bounds = self.bounds\r\n if bounds is None or (bounds[0] is None and bounds[1] is None): # no bounds ==> no penalty\r\n return self # len(function_values) * [0.0] # case without voilations\r\n\r\n N = es.N\r\n ### prepare\r\n # compute varis = sigma**2 * C_ii\r\n varis = es.sigma**2 * array(N * [es.C] if np.isscalar(es.C) else ( # scalar case\r\n es.C if np.isscalar(es.C[0]) else # diagonal matrix case\r\n [es.C[i][i] for i in xrange(N)])) # full matrix case\r\n\r\n # dmean = (es.mean - es.gp.into_bounds(es.mean)) / varis**0.5\r\n dmean = (es.mean - es.gp.geno(es.gp.into_bounds(es.gp.pheno(es.mean)))) / varis**0.5\r\n\r\n ### Store/update a history of delta fitness value\r\n fvals = sorted(function_values)\r\n l = 1 + len(fvals)\r\n val = fvals[3*l // 4] - fvals[l // 4] # exact interquartile range apart interpolation\r\n val = val / np.mean(varis) # new: val is normalized with sigma of the same iteration\r\n # insert val in history\r\n if np.isfinite(val) and val > 0:\r\n self.hist.insert(0, val)\r\n elif val == inf and len(self.hist) > 1:\r\n self.hist.insert(0, max(self.hist))\r\n else:\r\n pass # ignore 0 or nan values\r\n if len(self.hist) > 20 + (3*N) / es.popsize:\r\n self.hist.pop()\r\n\r\n ### prepare\r\n dfit = np.median(self.hist) # median interquartile range\r\n damp = min(1, es.sp.mueff/10./N)\r\n\r\n ### set/update weights\r\n # Throw initialization error\r\n if len(self.hist) == 0:\r\n raise _Error('wrongful initialization, no feasible solution sampled. ' +\r\n 'Reasons can be mistakenly set bounds (lower bound not smaller than upper bound) or a too large initial sigma0 or... ' +\r\n 'See description of argument func in help(cma.fmin) or an example handling infeasible solutions in help(cma.CMAEvolutionStrategy). ')\r\n # initialize weights\r\n if (dmean.any() and (not self.weights_initialized or es.countiter == 2)): # TODO\r\n self.gamma = array(N * [2*dfit])\r\n self.weights_initialized = True\r\n # update weights gamma\r\n if self.weights_initialized:\r\n edist = array(abs(dmean) - 3 * max(1, N**0.5/es.sp.mueff))\r\n if 1 < 3: # this is better, around a factor of two\r\n # increase single weights possibly with a faster rate than they can decrease\r\n # value unit of edst is std dev, 3==random walk of 9 steps\r\n self.gamma *= exp((edist>0) * np.tanh(edist/3) / 2.)**damp\r\n # decrease all weights up to the same level to avoid single extremely small weights\r\n # use a constant factor for pseudo-keeping invariance\r\n self.gamma[self.gamma > 5 * dfit] *= exp(-1./3)**damp\r\n # self.gamma[idx] *= exp(5*dfit/self.gamma[idx] - 1)**(damp/3)\r\n elif 1 < 3 and (edist>0).any(): # previous method\r\n # CAVE: min was max in TEC 2009\r\n self.gamma[edist>0] *= 1.1**min(1, es.sp.mueff/10./N)\r\n # max fails on cigtab(N=12,bounds=[0.1,None]):\r\n # self.gamma[edist>0] *= 1.1**max(1, es.sp.mueff/10./N) # this was a bug!?\r\n # self.gamma *= exp((edist>0) * np.tanh(edist))**min(1, es.sp.mueff/10./N)\r\n else: # alternative version, but not better\r\n solutions = es.pop # this has not been checked\r\n r = self.feasible_ratio(solutions) # has to be the averaged over N iterations\r\n self.gamma *= exp(np.max([N*[0], 0.3 - r], axis=0))**min(1, es.sp.mueff/10/N)\r\n es.more_to_write += list(self.gamma) if self.weights_initialized else N * [1.0]\r\n ### return penalty\r\n # es.more_to_write = self.gamma if not np.isscalar(self.gamma) else N*[1]\r\n return self # bound penalty values\r","def romberg(f, a, b, n=20):\n R = [[0.5 * (b - a) * (f(a) + f(b))]] # R[0][0]\n for n in range (1,n+1):\n h = float(b-a)/2**n\n R.append((n+1)*[None]) # Add an empty row.\n R[n][0] = 0.5*R[n-1][0] + h*sum(f(a+(2*k-1)*h) for k in range(1, 2**(n-1)+1)) # for proper limits\n for m in range(1, n+1):\n R[n][m] = R[n][m-1] + (R[n][m-1] - R[n-1][m-1]) / (4**m - 1)\n return R[n][n]","def nu0(self, Td):\n f = lambda nu: self.bCIB + self.cCIB + self.dLnBlackdLnNu(nu, Td)\n nuMin = 1.e1 * 1.e9 # in Hz\n nuMax = 1.e5 * 1.e9 # in Hz\n '''\n Nu = np.linspace(nuMin, nuMax, 201)\n F = np.array(map(f, Nu))\n plt.semilogx(Nu, F)\n plt.semilogx(Nu, 0.*Nu)\n plt.show()\n '''\n result = optimize.brentq(f , nuMin, nuMax)\n return result","def f(x, y):\n return Ripple.g(np.sqrt(x ** 2 + y ** 2))","def cdf(self, value):\n cdf = torch.where(\n value < 1., \n self.base.cdf(value), \n torch.ones_like(value) # all of the mass\n )\n cdf = torch.where(value < 0., torch.zeros_like(cdf), cdf)\n return cdf","def calculate_fn_value(self) :\r\n\r\n self.fn_value = self.gn_value + self.hn_value #f(n) = g(n) + h(n)\r","def expected_improvement(f_min, mu, sigma):\n # log-scaling might not be the best idea here, especially\n # if people use negative values to maximize output\n # v = (np.log(f_min) - mu) / sigma\n v = (f_min - mu) / sigma\n return (f_min * norm.cdf(v)\n - (np.exp(0.5 * sigma ** 2 + mu)\n * norm.cdf(v - sigma)))","def beeston_barlow_root2(a, p, U, d):\n return ((-U*p - U + a*p + d*p +\n np.sqrt(U**2*p**2 + 2*U**2*p + U**2 + 2*U*a*p**2 + 2*U*a*p -\n 2*U*d*p**2 - 2*U*d*p + a**2*p**2 + 2*a*d*p**2 + d**2*p**2))/(2*p*(p + 1)))","def theoretical_distribution(x):\n a = 0\n b = 1\n if x < a:\n return 0\n elif x > b:\n return 1\n else:\n return float(x - a) / (b - a)","def beeston_barlow_root1(a, p, U, d):\n return ((-U*p - U + a*p + d*p -\n np.sqrt(U**2*p**2 + 2*U**2*p + U**2 + 2*U*a*p**2 + 2*U*a*p -\n 2*U*d*p**2 - 2*U*d*p + a**2*p**2 + 2*a*d*p**2 + d**2*p**2))/(2*p*(p + 1)))","def normal_upper_bound(probability: float, mu: float = 0, sigma: float = 1) -> float:\n return inverse_normal_cdf(probability, mu, sigma)","def fdq2(f, x, h=1e-5):\n return (-3*f(x) + 4*f(x+h) - f(x+2*h))/(2*h)\n raise NotImplementedError(\"Problem 2 Incomplete\")","def H(cur_bid, cur_bidder_value, active_values):\r\n return (np.log(cur_bidder_value - cur_bid) -\r\n sum(np.log(np.array(active_values) - cur_bid)) / (len(active_values) - 1.0))","def value(self): \r\n c = self.nd1() * self.s * math.exp(-self.div * self.t)\r\n c -= self.nd2() * self.x * math.exp(-self.rf * self.t)\r\n \r\n return c","def bessel_value(m, x):\n return (1 / math.pi) * trapezium_rule(bessel, m, x, 0, math.pi, 10000)","def cdf(self, value):\n return self._normal.cdf(value)","def _ei_acq(x):\n mu, sigma = gp.eval(x, uncert_form='std')\n Z = (mu - curr_best) / sigma\n return (mu - curr_best)*normal_distro.cdf(Z) + sigma*normal_distro.pdf(Z)","def CalcForceDistribution(self):\n\t\t\n\t\tself.F = self.s * (self.Tether - self.X)\n\t\t\n\t\treturn self.F","def heisenberg_pd(self, idx):\n # get the gradient recipe for this parameter\n recipe = self.grad_recipe[idx]\n multiplier = 0.5 if recipe is None else recipe[0]\n shift = np.pi / 2 if recipe is None else recipe[1]\n\n p = self.parameters\n # evaluate the transform at the shifted parameter values\n p[idx] += shift\n U2 = self._heisenberg_rep(p) # pylint: disable=assignment-from-none\n p[idx] -= 2*shift\n U1 = self._heisenberg_rep(p) # pylint: disable=assignment-from-none\n return (U2-U1) * multiplier # partial derivative of the transformation","def calculate(i: int, j: int) -> float:\n if self.ca[i, j] > -1.0:\n return self.ca[i, j]\n\n d = self.dist[i, j]\n if i == 0 and j == 0:\n self.ca[i, j] = d\n elif i > 0 and j == 0:\n self.ca[i, j] = max(calculate(i - 1, 0), d)\n elif i == 0 and j > 0:\n self.ca[i, j] = max(calculate(0, j - 1), d)\n elif i > 0 and j > 0:\n self.ca[i, j] = max(\n min(\n calculate(i - 1, j),\n calculate(i - 1, j - 1),\n calculate(i, j - 1),\n ),\n d,\n )\n else:\n self.ca[i, j] = np.infty\n return self.ca[i, j]","def __R1(x: float) -> np.float64:\n if np.abs(x) < end:\n return np.float64((1 / np.pi) * np.sqrt(2 * N - x * x))\n return np.float64(0.0)","def compute_f_CHEN(self, R, e, D):\n upper_RHS_LHS = e/D\n lower_RHS_LHS = 3.7065\n \n log_square = log((((upper_RHS_LHS)**1.1096)/2.8257) + (7.149/R)**0.8961, 10)\n LHS_RHS_RHS = (5.0452/R) * log_square\n \n curly_bracket = (upper_RHS_LHS / lower_RHS_LHS) - LHS_RHS_RHS\n \n RHS = (-4)*log(curly_bracket, 10)\n f = (1/RHS)**2\n\n return f","def calc(self,newValue):\n return np.sum(self.values<=newValue)/self.n","def rate_density(self, value):\n\n # TODO: analyse for certain that log units cancel out\n # with the change in occr\n\n if value.ndim == 2:\n value = value.T\n\n R_i = np.digitize(value[0], self._R_boundaries) - 1\n P_i = np.digitize(value[1], self._P_boundaries) - 1\n\n # Remove the ones out of bounds (oob_mask = out of bounds mask)\n oob_mask = np.zeros_like(R_i, dtype=bool)\n oob_mask = oob_mask | ((R_i < 0) | (R_i >= np.shape(self.occr)[0]))\n oob_mask = oob_mask | ((P_i < 0) | (P_i >= len(self._P_boundaries)-1))\n\n R_i = R_i[~oob_mask]\n P_i = P_i[~oob_mask]\n\n return self.occr[R_i] * self._cpf_grid[R_i, P_i]","def B(q):\n # print('Value q')\n # print(q)\n if q > 0 and q != 0 and q != 1:\n result = -(q*math.log(q,2) + (1-q)*math.log(1-q,2))\n else:\n result = 0\n # print('Result of B')\n # print(result)\n return result","def central_differences(f, h, x):\n\treturn (f(x + h) - f(x - h)) / (2 * h)","def central_x(self, func):\n\n roll_left = np.roll(func, -1, axis=1)\n roll_right = np.roll(func, 1, axis=1)\n f_dx = (roll_left - roll_right) / (2 * self.dx)\n return f_dx","def x_density_function(self, x):\n return self.wavefunction(x) * self.wavefunction(x)","def f(self, x: np.array) -> np.array:\n return (1/np.sqrt(2*np.pi*self.sig**2))*np.exp(-1*((x - self.mu)**2/(2*self.sig**2)))","def fn(i, j):\n if i == m-1 and j == n-1: return max(1, 1 - dungeon[i][j])\n if i > m-1 or j > n-1: return inf\n return max(1, min(fn(i+1, j), fn(i, j+1)) - dungeon[i][j])","def bn(x, e=1e-7):\n mu = np.mean(x)\n sigma2 = np.var(x)\n x_ = (x - mu) / np.sqrt(sigma2 + e)\n return x_","def dalf(x):\n return grad(alf)(x)","def relative_partition_function(self):\n return self.overall_norm**2","def far(self):\n return self.table[0, 1] / (self.table[0, 0] + self.table[0, 1])","def dalf(x):\n return derivative(alf, x, dx=1e-6)","def _call(self, x):\n if functional.prior is None:\n return (-1.0) / x + 1\n else:\n return (-functional.prior) / x + 1","def fn(u):\n if u == n-1: return 1 # boundary condition \n ans = 0\n for v, _ in graph[u]: \n if dist[u] > dist[v]: ans += fn(v)\n return ans","def prob_distr(self, x):\n return 1.0/x","def evaluate_one(self, x):\n # p = 1. / (np.sqrt(2. * np.pi) * self.sigma) * \\\n # np.exp(-0.5 * (self.mean - x) * self.invvar * (self.mean - x))\n p = self.dist.probability(x)\n return p","def doubling_gauss(f, xl: float, xr: float, n: int, tol: float, *params):\n # required local variables to return\n # S : computed value of the integral with required tolerance\n # N : number of steps for S\n # err : estimated error of S\n # iter : number of iterations (steps doubling)\n iter = 1\n N = 10\n m = (2 * n - 1) + 1\n\n # считаем интеграл с шагом h\n s1 = composite_gauss(f, xl, xr, N, n, *params)\n # цикл по итерациям\n while iter != MAXITER + 1:\n N *= 2\n # считаем интеграл с шагом h/2\n s2 = composite_gauss(f, xl, xr, N, n, *params)\n\n # берём погрешность из метода рунге\n estimate = np.abs(runge(s1, s2, 2, m))\n if estimate >= tol:\n s1 = s2\n else:\n return N, s2, estimate\n\n iter += 1\n\n if iter == MAXITER:\n print(\"Convergence not reached!\")\n return -1","def calc_peq(self, F):\n result = np.exp(self.Integrate(F))\n result /= np.sum(result * self.w_d_)\n return result","def getElementFunction(element):\n energies, fluxes = getElementData(element)\n fluxes = energies*fluxes\n logEnergies = np.log10(energies)\n logFluxes = np.log10(fluxes)\n bins, samples = binnedAverage(logEnergies, logFluxes, bins=10)\n f = scipy.interpolate.interp1d(bins, samples, kind='cubic')\n return min(bins), max(bins), f","def ecdf(x, xw=None):\n\n if xw is None:\n xw = np.ones(len(x))\n\n w_sum = xw.sum()\n\n if w_sum <= 0:\n raise ValueError(\"Normalisation of weights should be positive, is: \",\n w_sum)\n\n # Sort if not sorted\n if not (np.diff(x) >= 0).all():\n idx = np.argsort(x)\n\n try:\n x = x.iloc[idx]\n except AttributeError:\n x = x[idx]\n try:\n xw = xw.iloc[idx]\n except AttributeError:\n xw = xw[idx]\n\n # Accumulate weights\n m = np.vstack(((-np.inf, 0), # required for values < min(x)\n np.column_stack((x, np.cumsum(xw / w_sum)))))\n\n # Return a function which gives the value of the ECDF at a given x\n # (vectoried for array-like objects!)\n return lambda v: m[np.searchsorted(m[:, 0], v, side=\"right\") - 1, 1]","def func(x, f, fp):\n\n return np.sqrt((1+fp(x)**2) / (2 * g * f(x)))","def unitary_Gauss(x, center, FWHM):\n \n sigma = np.abs(FWHM) /( 2 * np.sqrt(2 * np.log(2)) );\n Amp = 1.0 / (sigma*np.sqrt(2*np.pi))\n tau = -((x - center)**2) / (2*(sigma**2))\n result = Amp * np.exp( tau );\n \n return result","def fn(self, x):\n\n return math.exp(x*2) - math.exp(x) - 2","def fn(self, x):\n\n return math.exp(x*2) - math.exp(x) - 2","def fix_rand_value(lo_bound: float, up_bound: float) -> float:\n # In this patch test function for determinism, just return lower bound\n nonlocal _i, _vals_sequence\n v_return = _vals_sequence[_i]\n _i = (_i + 1) % len(_vals_sequence)\n return v_return","def pchisq(x, df):\n \n if df % 2 == 0:\n dchi = 0.5 * math.exp(-0.5 * x)\n f = 1.0 - 2.0 * dchi\n for i in range(4, df + 1, 2):\n dchi *= x / (i - 2)\n f -= 2.0 * dchi\n \n else:\n f = 2.0 * pnorm(math.sqrt(x), 0.0, 1.0) - 1.0\n dchi = math.exp(-0.5 * x) / math.sqrt(2.0 * math.pi * x)\n for i in range(3, df + 1, 2):\n dchi *= x / (i - 2)\n f -= 2.0 * dchi\n \n return f","def _call(self, x):\n if self.prior is None:\n tmp = -1.0 * (np.log(1 - x)).inner(self.domain.one())\n else:\n tmp = (-self.prior * np.log(1 - x)).inner(self.domain.one())\n if np.isnan(tmp):\n # In this case, some element was larger than or equal to one\n return np.inf\n else:\n return tmp","def empirical_distribution(data, x, n):\n i = 0\n while i < n and data[i] <= x:\n i+=1\n return float(i)/n","def cdfFunction(f, x, N):\r\n return ssstats.binom.cdf(x, N, f)","def cdf(self,x):\n if self.base == 'natural':\n cdfValue = (math.log(x)-self.lowerBound)/(self.upperBound-self.lowerBound)\n else:\n cdfValue = (math.log10(x)-self.lowerBound)/(self.upperBound-self.lowerBound)\n return cdfValue","def pofd(self):\n return self.table[0, 1] / (self.table[0, 1] + self.table[1, 1])","def f(x):\n return delta_eps_mu(x, mu) - delta","def gaussian_cdf(x, _erf=erf):\n return (1 + _erf(x / math.sqrt(2))) / 2","def gauss_term_fn(iteration_count, v, z):\n return tf.math.square(z) / 4. / (\n (v + iteration_count - 1) * (v + iteration_count))","def GetValue(self, *args):\n return _ITKCostFunctionsPython.itkCumulativeGaussianCostFunction_GetValue(self, *args)"],"string":"[\n \"def erfc(x):\\n return 0.0\",\n \"def gaussed_value(self):\\n from random import gauss\\n return sorted([0, int(gauss(self.value, self.sigma)), \\\\\\n (self.size*8)-1])[1]\",\n \"def normalizefunction(self , values):\\n maxv = np.max(values)\\n minv = np.min(values)\\n def f(x):\\n return (x - minv)/(maxv-minv)\\n return f\",\n \"def get_value(self) -> float:\\n return random.gauss(self._mu, self._sigma)\",\n \"def fluence(self, range_x):\\n time_step = np.diff(range_x)\\n val_square = np.square(np.abs(self(range_x)))\\n res = np.sum(np.array(val_square[:-1] * time_step))\\n res = res/(range_x[-1] - range_x[0])\\n return res\",\n \"def fdq1(f, x, h=1e-5):\\n return (f(x+h) - f(x))/h\\n \\n raise NotImplementedError(\\\"Problem 2 Incomplete\\\")\",\n \"def f(a):\\n b = a * 2\\n while b.norm().asscalar() < 1000:\\n b = b * 2\\n if b.sum().asscalar() > 0:\\n c = b\\n else:\\n c = 100 * b\\n return c\",\n \"def bdq1(f, x, h=1e-5):\\n return (f(x)-f(x-h))/h\\n raise NotImplementedError(\\\"Problem 2 Incomplete\\\")\",\n \"def bisection(f, fu, point_a, point_b, point_c, point_d, lower_bound, upper_bound, length):\\n n = 1\\n theta = 0\\n a = lower_bound\\n b = upper_bound\\n while n <= 100:\\n theta = (a + b) / 2.0\\n if -1e-6 < f(fu(point_a, point_b, point_c, theta), point_d) - length < 1e-6:\\n # print 'Residual', f(fu(point_a, point_b, point_c, theta), point_d) - length\\n # print 'iteration', n\\n return theta\\n else:\\n n = n + 1\\n if f(fu(point_a, point_b, point_c, theta), point_d) - length > 0:\\n b = theta\\n else:\\n a = theta\\n\\n print 'failedtheta', theta, 'Residual', f(fu(point_a, point_b, point_c, theta), point_d) - length\\n print 'iteration', n\\n return False\",\n \"def fn(val):\\n if val < x: return min(2*val-1, 2*(x-val))\\n k = int(log(val)//log(x))\\n ans = k + fn(val - x**k)\\n if x**(k+1) < 2*val: \\n ans = min(ans, k + 1 + fn(x**(k+1) - val))\\n return ans\",\n \"def fom(self):\\n return self.table[1, 0] / (self.table[0, 0] + self.table[1, 0])\",\n \"def exprenyi(alpha, sigma, top, bottom):\\n return siquad(getdensity(alpha, sigma, top, bottom),\\n -np.infty, np.infty)[0]\",\n \"def integrate_gausskronrod(f, a, b, args=()):\\n\\n assert b > a\\n mid = 0.5*(b+a)\\n dx = 0.5*(b-a)\\n zi = mid+gausskronrod_nodes*dx\\n integrand = f(zi)\\n integral_G7 = np.sum(integrand[:7]*gauss_weights)\\n integral_K15 = np.sum(integrand*kronrod_weights)\\n\\n error = (200*abs(integral_G7-integral_K15))**1.5\\n\\n return integral_K15*dx, dx*error\",\n \"def fn(i, j):\\n if i == 0 and j == 0: return grid[i][j]\\n if i < 0 or j < 0: return float(\\\"inf\\\")\\n return grid[i][j] + min(fn(i-1, j), fn(i, j-1))\",\n \"def fn(i, j):\\n if i == 0 and j == 0: return grid[i][j]\\n if i < 0 or j < 0: return float(\\\"inf\\\")\\n return grid[i][j] + min(fn(i-1, j), fn(i, j-1))\",\n \"def F(x):\\n return math.exp(-0.5 * (x ** 2))\",\n \"def compute_fk(self, sigma, sigma_des, C, offset):\\n if sigma >= sigma_des:\\n # push robot away\\n f = -((sigma - sigma_des) ** 2)/C + offset\\n elif sigma < sigma_des:\\n # pull robot in\\n f = ((sigma - sigma_des) ** 2)/C + offset\\n else:\\n f = 0\\n return f\",\n \"def density(temp,pres):\\n g_p = liq_g(0,1,temp,pres)\\n dliq = g_p**(-1)\\n return dliq\",\n \"def norm_cdf(self, x):\\n k = 1.0/(1.0+0.2316419*x)\\n k_sum = k * (0.319381530 + k * (-0.356563782 + \\\\\\n k * (1.781477937 + k * (-1.821255978 + 1.330274429 * k))))\\n \\n if x >= 0.0:\\n return (1.0 - (1.0 / ((2 * pi)**0.5)) * exp(-0.5 * x * x) * k_sum)\\n else:\\n return 1.0 - self.norm_cdf(-x)\",\n \"def real_value(val):\\n\\t\\treturn round(val/100*sum(euros), 1)\",\n \"def radial_distribution_function(alpha):\\n\\n ALPHA_MAX = 0.59999\\n\\n ALPHA0 =0.6\\n\\n numpy.where(alpha > ALPHA_MAX, ALPHA_MAX, alpha)\\n\\n return 1.0/(1.0-(alpha/ALPHA0)**(1.0/3.0))\",\n \"def gauss_wp(self, delta, x0=0):\\n constant = (delta/np.pi)**(1/4) * (1.+0.j) \\n wp = constant * np.exp((-0.5 * delta * np.square(self.grid_x - x0)))\\n return wp\",\n \"def density(self, arg):\\n return self.gb2_density(np.exp(arg)) * np.exp(arg)\",\n \"def _analytical_cdf_term(self, j, t):\\n\\n try:\\n\\n return ((1 - np.cos(j * np.pi)) / j) * np.sin(j * np.pi * self.x0 / self.L) * \\\\\\n np.exp(-(j * np.pi * self.sigma / self.L) ** 2 * t)\\n\\n except FloatingPointError: # at large t, the exponential term gets REALLY small causing an underflow\\n return 0\",\n \"def g(f, x: float):\\n return lambda x: f(x + f(x)) / f(x) - 1\",\n \"def apply(cls, x):\\n return np.maximum(0, np.minimum(1, 0.2*x + 0.5))\",\n \"def calculate(i: int, j: int) -> float:\\n if self.ca[i, j] > -1.0:\\n return self.ca[i, j]\\n\\n d = self.dist_func(p[i], q[j])\\n if i == 0 and j == 0:\\n self.ca[i, j] = d\\n elif i > 0 and j == 0:\\n self.ca[i, j] = max(calculate(i - 1, 0), d)\\n elif i == 0 and j > 0:\\n self.ca[i, j] = max(calculate(0, j - 1), d)\\n elif i > 0 and j > 0:\\n self.ca[i, j] = max(\\n min(\\n calculate(i - 1, j),\\n calculate(i - 1, j - 1),\\n calculate(i, j - 1),\\n ),\\n d,\\n )\\n else:\\n self.ca[i, j] = np.infty\\n return self.ca[i, j]\",\n \"def frobenius(self, value):\\n return sum(self.hadamard(value))\",\n \"def erf(x):\\n return 0.0\",\n \"def calc(self,newValue):\\n idx=np.searchsorted(self.quantiles, newValue, side=\\\"left\\\")\\n if idx>=self.n-1:\\n return idx/self.n\\n if np.abs(newValue - self.quantiles[idx-1]) < np.abs(newValue - self.quantiles[idx]):\\n return (idx-1)/self.n\\n else:\\n return idx/self.n\",\n \"def f(x):\\n\\treturn (sc.log(x**2+5)*sc.cos(0.8*x)+3.5*x)/(sc.e**(x/10))\",\n \"def weibull(self, x):\\n return (self.k_alp[0]/self.k_alp[1])*(math.pow(x/self.k_alp[1],(self.k_alp[0]-1))) * \\\\\\n np.exp(-1*math.pow(x/self.k_alp[1],self.k_alp[0]))\",\n \"def eo_numerical(th):\\n res = integrate.dblquad(gaussian_func_2dim_extra, th, np.inf, lambda x: th, lambda x: np.inf)\\n return res[0]\",\n \"def fvec_callable(self, values):\\n\\n all_sigmas_normalized, _ = self.get_normalized_sigmas(values)\\n f = flex.double()\\n for i, bin in enumerate(self.bins):\\n binned_normalized_sigmas = all_sigmas_normalized.select(bin)\\n n = len(binned_normalized_sigmas)\\n if n == 0:\\n f.append(0)\\n continue\\n # functional is weight * (1-rms(normalized_sigmas))^s summed over all intensitiy bins\\n f.append(1-math.sqrt(flex.mean(binned_normalized_sigmas*binned_normalized_sigmas)))\\n\\n if self.scaler.params.raw_data.error_models.sdfac_refine.plot_refinement_steps:\\n all_sigmas_normalized = all_sigmas_normalized.select(all_sigmas_normalized != 0)\\n print(self.modeler.normal_probability_plot(all_sigmas_normalized, (-0.5, 0.5), plot = True))\\n return f\",\n \"def DDG(self, n, e, r, f):\\n pre = (-e[:, None] + np.divide.outer((n - 1), r))**2\\n pre -= np.divide.outer((n - 1), r**2)\\n return pre*f\",\n \"def ecdf(x0, w=None):\\n n = len(x0)\\n\\n if w is None:\\n w = np.ones(n) / n\\n else:\\n w = w / np.sum(w)\\n p = np.cumsum(np.r_[[0], w])[:-1]\\n # p = np.linspace(0, 1, n + 1)[:-1]\\n\\n x = np.sort(x0)\\n return p, x\",\n \"def _compute_f(self, p, dh, dv):\\n return dh / (self.beta * p * dv)\",\n \"def fun_gauss(p,r):\\n return p[1] * np.exp(-((r/p[0])**2))\",\n \"def dfr(self):\\n return self.table[1, 0] / (self.table[1, 0] + self.table[1, 1])\",\n \"def e(self):\\n if self._e is None:\\n # self._e = self.distributions.uniform(0.3,0.33)\\n # return self._e\\n # max is set by q but also limited by users choice of e_max.\\n res_a = 29.9*((self.j[0]/self.k[0])**(2/3))\\n q = self.distributions.truncated_normal(self.q_c, self.q_w, res_a*(1-0.8), res_a*(1-0.001))\\n self._e = 1 - q/res_a\\n return self._e\",\n \"def value(a, y):\\n\\t\\treturn 0.5*np.linalg.norm(a-y)**2\",\n \"def upper_bound(self) -> float:\\n ...\",\n \"def numerical_gradient(f, x: np.ndarray):\\n h = 1e-4\\n grad = np.zeros_like(x)\\n for i in range(x.size):\\n tmp_val = x.flat[i]\\n x.flat[i] = tmp_val + h\\n fxh1 = f(x)\\n\\n x.flat[i] = tmp_val - h\\n fxh2 = f(x)\\n grad.flat[i] = (fxh1 - fxh2) / (2 * h)\\n x.flat[i] = tmp_val\\n return grad\",\n \"def update(self, function_values, es, bounds=None):\\r\\n if bounds is None:\\r\\n bounds = self.bounds\\r\\n if bounds is None or (bounds[0] is None and bounds[1] is None): # no bounds ==> no penalty\\r\\n return self # len(function_values) * [0.0] # case without voilations\\r\\n\\r\\n N = es.N\\r\\n ### prepare\\r\\n # compute varis = sigma**2 * C_ii\\r\\n varis = es.sigma**2 * array(N * [es.C] if np.isscalar(es.C) else ( # scalar case\\r\\n es.C if np.isscalar(es.C[0]) else # diagonal matrix case\\r\\n [es.C[i][i] for i in xrange(N)])) # full matrix case\\r\\n\\r\\n # dmean = (es.mean - es.gp.into_bounds(es.mean)) / varis**0.5\\r\\n dmean = (es.mean - es.gp.geno(es.gp.into_bounds(es.gp.pheno(es.mean)))) / varis**0.5\\r\\n\\r\\n ### Store/update a history of delta fitness value\\r\\n fvals = sorted(function_values)\\r\\n l = 1 + len(fvals)\\r\\n val = fvals[3*l // 4] - fvals[l // 4] # exact interquartile range apart interpolation\\r\\n val = val / np.mean(varis) # new: val is normalized with sigma of the same iteration\\r\\n # insert val in history\\r\\n if np.isfinite(val) and val > 0:\\r\\n self.hist.insert(0, val)\\r\\n elif val == inf and len(self.hist) > 1:\\r\\n self.hist.insert(0, max(self.hist))\\r\\n else:\\r\\n pass # ignore 0 or nan values\\r\\n if len(self.hist) > 20 + (3*N) / es.popsize:\\r\\n self.hist.pop()\\r\\n\\r\\n ### prepare\\r\\n dfit = np.median(self.hist) # median interquartile range\\r\\n damp = min(1, es.sp.mueff/10./N)\\r\\n\\r\\n ### set/update weights\\r\\n # Throw initialization error\\r\\n if len(self.hist) == 0:\\r\\n raise _Error('wrongful initialization, no feasible solution sampled. ' +\\r\\n 'Reasons can be mistakenly set bounds (lower bound not smaller than upper bound) or a too large initial sigma0 or... ' +\\r\\n 'See description of argument func in help(cma.fmin) or an example handling infeasible solutions in help(cma.CMAEvolutionStrategy). ')\\r\\n # initialize weights\\r\\n if (dmean.any() and (not self.weights_initialized or es.countiter == 2)): # TODO\\r\\n self.gamma = array(N * [2*dfit])\\r\\n self.weights_initialized = True\\r\\n # update weights gamma\\r\\n if self.weights_initialized:\\r\\n edist = array(abs(dmean) - 3 * max(1, N**0.5/es.sp.mueff))\\r\\n if 1 < 3: # this is better, around a factor of two\\r\\n # increase single weights possibly with a faster rate than they can decrease\\r\\n # value unit of edst is std dev, 3==random walk of 9 steps\\r\\n self.gamma *= exp((edist>0) * np.tanh(edist/3) / 2.)**damp\\r\\n # decrease all weights up to the same level to avoid single extremely small weights\\r\\n # use a constant factor for pseudo-keeping invariance\\r\\n self.gamma[self.gamma > 5 * dfit] *= exp(-1./3)**damp\\r\\n # self.gamma[idx] *= exp(5*dfit/self.gamma[idx] - 1)**(damp/3)\\r\\n elif 1 < 3 and (edist>0).any(): # previous method\\r\\n # CAVE: min was max in TEC 2009\\r\\n self.gamma[edist>0] *= 1.1**min(1, es.sp.mueff/10./N)\\r\\n # max fails on cigtab(N=12,bounds=[0.1,None]):\\r\\n # self.gamma[edist>0] *= 1.1**max(1, es.sp.mueff/10./N) # this was a bug!?\\r\\n # self.gamma *= exp((edist>0) * np.tanh(edist))**min(1, es.sp.mueff/10./N)\\r\\n else: # alternative version, but not better\\r\\n solutions = es.pop # this has not been checked\\r\\n r = self.feasible_ratio(solutions) # has to be the averaged over N iterations\\r\\n self.gamma *= exp(np.max([N*[0], 0.3 - r], axis=0))**min(1, es.sp.mueff/10/N)\\r\\n es.more_to_write += list(self.gamma) if self.weights_initialized else N * [1.0]\\r\\n ### return penalty\\r\\n # es.more_to_write = self.gamma if not np.isscalar(self.gamma) else N*[1]\\r\\n return self # bound penalty values\\r\",\n \"def romberg(f, a, b, n=20):\\n R = [[0.5 * (b - a) * (f(a) + f(b))]] # R[0][0]\\n for n in range (1,n+1):\\n h = float(b-a)/2**n\\n R.append((n+1)*[None]) # Add an empty row.\\n R[n][0] = 0.5*R[n-1][0] + h*sum(f(a+(2*k-1)*h) for k in range(1, 2**(n-1)+1)) # for proper limits\\n for m in range(1, n+1):\\n R[n][m] = R[n][m-1] + (R[n][m-1] - R[n-1][m-1]) / (4**m - 1)\\n return R[n][n]\",\n \"def nu0(self, Td):\\n f = lambda nu: self.bCIB + self.cCIB + self.dLnBlackdLnNu(nu, Td)\\n nuMin = 1.e1 * 1.e9 # in Hz\\n nuMax = 1.e5 * 1.e9 # in Hz\\n '''\\n Nu = np.linspace(nuMin, nuMax, 201)\\n F = np.array(map(f, Nu))\\n plt.semilogx(Nu, F)\\n plt.semilogx(Nu, 0.*Nu)\\n plt.show()\\n '''\\n result = optimize.brentq(f , nuMin, nuMax)\\n return result\",\n \"def f(x, y):\\n return Ripple.g(np.sqrt(x ** 2 + y ** 2))\",\n \"def cdf(self, value):\\n cdf = torch.where(\\n value < 1., \\n self.base.cdf(value), \\n torch.ones_like(value) # all of the mass\\n )\\n cdf = torch.where(value < 0., torch.zeros_like(cdf), cdf)\\n return cdf\",\n \"def calculate_fn_value(self) :\\r\\n\\r\\n self.fn_value = self.gn_value + self.hn_value #f(n) = g(n) + h(n)\\r\",\n \"def expected_improvement(f_min, mu, sigma):\\n # log-scaling might not be the best idea here, especially\\n # if people use negative values to maximize output\\n # v = (np.log(f_min) - mu) / sigma\\n v = (f_min - mu) / sigma\\n return (f_min * norm.cdf(v)\\n - (np.exp(0.5 * sigma ** 2 + mu)\\n * norm.cdf(v - sigma)))\",\n \"def beeston_barlow_root2(a, p, U, d):\\n return ((-U*p - U + a*p + d*p +\\n np.sqrt(U**2*p**2 + 2*U**2*p + U**2 + 2*U*a*p**2 + 2*U*a*p -\\n 2*U*d*p**2 - 2*U*d*p + a**2*p**2 + 2*a*d*p**2 + d**2*p**2))/(2*p*(p + 1)))\",\n \"def theoretical_distribution(x):\\n a = 0\\n b = 1\\n if x < a:\\n return 0\\n elif x > b:\\n return 1\\n else:\\n return float(x - a) / (b - a)\",\n \"def beeston_barlow_root1(a, p, U, d):\\n return ((-U*p - U + a*p + d*p -\\n np.sqrt(U**2*p**2 + 2*U**2*p + U**2 + 2*U*a*p**2 + 2*U*a*p -\\n 2*U*d*p**2 - 2*U*d*p + a**2*p**2 + 2*a*d*p**2 + d**2*p**2))/(2*p*(p + 1)))\",\n \"def normal_upper_bound(probability: float, mu: float = 0, sigma: float = 1) -> float:\\n return inverse_normal_cdf(probability, mu, sigma)\",\n \"def fdq2(f, x, h=1e-5):\\n return (-3*f(x) + 4*f(x+h) - f(x+2*h))/(2*h)\\n raise NotImplementedError(\\\"Problem 2 Incomplete\\\")\",\n \"def H(cur_bid, cur_bidder_value, active_values):\\r\\n return (np.log(cur_bidder_value - cur_bid) -\\r\\n sum(np.log(np.array(active_values) - cur_bid)) / (len(active_values) - 1.0))\",\n \"def value(self): \\r\\n c = self.nd1() * self.s * math.exp(-self.div * self.t)\\r\\n c -= self.nd2() * self.x * math.exp(-self.rf * self.t)\\r\\n \\r\\n return c\",\n \"def bessel_value(m, x):\\n return (1 / math.pi) * trapezium_rule(bessel, m, x, 0, math.pi, 10000)\",\n \"def cdf(self, value):\\n return self._normal.cdf(value)\",\n \"def _ei_acq(x):\\n mu, sigma = gp.eval(x, uncert_form='std')\\n Z = (mu - curr_best) / sigma\\n return (mu - curr_best)*normal_distro.cdf(Z) + sigma*normal_distro.pdf(Z)\",\n \"def CalcForceDistribution(self):\\n\\t\\t\\n\\t\\tself.F = self.s * (self.Tether - self.X)\\n\\t\\t\\n\\t\\treturn self.F\",\n \"def heisenberg_pd(self, idx):\\n # get the gradient recipe for this parameter\\n recipe = self.grad_recipe[idx]\\n multiplier = 0.5 if recipe is None else recipe[0]\\n shift = np.pi / 2 if recipe is None else recipe[1]\\n\\n p = self.parameters\\n # evaluate the transform at the shifted parameter values\\n p[idx] += shift\\n U2 = self._heisenberg_rep(p) # pylint: disable=assignment-from-none\\n p[idx] -= 2*shift\\n U1 = self._heisenberg_rep(p) # pylint: disable=assignment-from-none\\n return (U2-U1) * multiplier # partial derivative of the transformation\",\n \"def calculate(i: int, j: int) -> float:\\n if self.ca[i, j] > -1.0:\\n return self.ca[i, j]\\n\\n d = self.dist[i, j]\\n if i == 0 and j == 0:\\n self.ca[i, j] = d\\n elif i > 0 and j == 0:\\n self.ca[i, j] = max(calculate(i - 1, 0), d)\\n elif i == 0 and j > 0:\\n self.ca[i, j] = max(calculate(0, j - 1), d)\\n elif i > 0 and j > 0:\\n self.ca[i, j] = max(\\n min(\\n calculate(i - 1, j),\\n calculate(i - 1, j - 1),\\n calculate(i, j - 1),\\n ),\\n d,\\n )\\n else:\\n self.ca[i, j] = np.infty\\n return self.ca[i, j]\",\n \"def __R1(x: float) -> np.float64:\\n if np.abs(x) < end:\\n return np.float64((1 / np.pi) * np.sqrt(2 * N - x * x))\\n return np.float64(0.0)\",\n \"def compute_f_CHEN(self, R, e, D):\\n upper_RHS_LHS = e/D\\n lower_RHS_LHS = 3.7065\\n \\n log_square = log((((upper_RHS_LHS)**1.1096)/2.8257) + (7.149/R)**0.8961, 10)\\n LHS_RHS_RHS = (5.0452/R) * log_square\\n \\n curly_bracket = (upper_RHS_LHS / lower_RHS_LHS) - LHS_RHS_RHS\\n \\n RHS = (-4)*log(curly_bracket, 10)\\n f = (1/RHS)**2\\n\\n return f\",\n \"def calc(self,newValue):\\n return np.sum(self.values<=newValue)/self.n\",\n \"def rate_density(self, value):\\n\\n # TODO: analyse for certain that log units cancel out\\n # with the change in occr\\n\\n if value.ndim == 2:\\n value = value.T\\n\\n R_i = np.digitize(value[0], self._R_boundaries) - 1\\n P_i = np.digitize(value[1], self._P_boundaries) - 1\\n\\n # Remove the ones out of bounds (oob_mask = out of bounds mask)\\n oob_mask = np.zeros_like(R_i, dtype=bool)\\n oob_mask = oob_mask | ((R_i < 0) | (R_i >= np.shape(self.occr)[0]))\\n oob_mask = oob_mask | ((P_i < 0) | (P_i >= len(self._P_boundaries)-1))\\n\\n R_i = R_i[~oob_mask]\\n P_i = P_i[~oob_mask]\\n\\n return self.occr[R_i] * self._cpf_grid[R_i, P_i]\",\n \"def B(q):\\n # print('Value q')\\n # print(q)\\n if q > 0 and q != 0 and q != 1:\\n result = -(q*math.log(q,2) + (1-q)*math.log(1-q,2))\\n else:\\n result = 0\\n # print('Result of B')\\n # print(result)\\n return result\",\n \"def central_differences(f, h, x):\\n\\treturn (f(x + h) - f(x - h)) / (2 * h)\",\n \"def central_x(self, func):\\n\\n roll_left = np.roll(func, -1, axis=1)\\n roll_right = np.roll(func, 1, axis=1)\\n f_dx = (roll_left - roll_right) / (2 * self.dx)\\n return f_dx\",\n \"def x_density_function(self, x):\\n return self.wavefunction(x) * self.wavefunction(x)\",\n \"def f(self, x: np.array) -> np.array:\\n return (1/np.sqrt(2*np.pi*self.sig**2))*np.exp(-1*((x - self.mu)**2/(2*self.sig**2)))\",\n \"def fn(i, j):\\n if i == m-1 and j == n-1: return max(1, 1 - dungeon[i][j])\\n if i > m-1 or j > n-1: return inf\\n return max(1, min(fn(i+1, j), fn(i, j+1)) - dungeon[i][j])\",\n \"def bn(x, e=1e-7):\\n mu = np.mean(x)\\n sigma2 = np.var(x)\\n x_ = (x - mu) / np.sqrt(sigma2 + e)\\n return x_\",\n \"def dalf(x):\\n return grad(alf)(x)\",\n \"def relative_partition_function(self):\\n return self.overall_norm**2\",\n \"def far(self):\\n return self.table[0, 1] / (self.table[0, 0] + self.table[0, 1])\",\n \"def dalf(x):\\n return derivative(alf, x, dx=1e-6)\",\n \"def _call(self, x):\\n if functional.prior is None:\\n return (-1.0) / x + 1\\n else:\\n return (-functional.prior) / x + 1\",\n \"def fn(u):\\n if u == n-1: return 1 # boundary condition \\n ans = 0\\n for v, _ in graph[u]: \\n if dist[u] > dist[v]: ans += fn(v)\\n return ans\",\n \"def prob_distr(self, x):\\n return 1.0/x\",\n \"def evaluate_one(self, x):\\n # p = 1. / (np.sqrt(2. * np.pi) * self.sigma) * \\\\\\n # np.exp(-0.5 * (self.mean - x) * self.invvar * (self.mean - x))\\n p = self.dist.probability(x)\\n return p\",\n \"def doubling_gauss(f, xl: float, xr: float, n: int, tol: float, *params):\\n # required local variables to return\\n # S : computed value of the integral with required tolerance\\n # N : number of steps for S\\n # err : estimated error of S\\n # iter : number of iterations (steps doubling)\\n iter = 1\\n N = 10\\n m = (2 * n - 1) + 1\\n\\n # считаем интеграл с шагом h\\n s1 = composite_gauss(f, xl, xr, N, n, *params)\\n # цикл по итерациям\\n while iter != MAXITER + 1:\\n N *= 2\\n # считаем интеграл с шагом h/2\\n s2 = composite_gauss(f, xl, xr, N, n, *params)\\n\\n # берём погрешность из метода рунге\\n estimate = np.abs(runge(s1, s2, 2, m))\\n if estimate >= tol:\\n s1 = s2\\n else:\\n return N, s2, estimate\\n\\n iter += 1\\n\\n if iter == MAXITER:\\n print(\\\"Convergence not reached!\\\")\\n return -1\",\n \"def calc_peq(self, F):\\n result = np.exp(self.Integrate(F))\\n result /= np.sum(result * self.w_d_)\\n return result\",\n \"def getElementFunction(element):\\n energies, fluxes = getElementData(element)\\n fluxes = energies*fluxes\\n logEnergies = np.log10(energies)\\n logFluxes = np.log10(fluxes)\\n bins, samples = binnedAverage(logEnergies, logFluxes, bins=10)\\n f = scipy.interpolate.interp1d(bins, samples, kind='cubic')\\n return min(bins), max(bins), f\",\n \"def ecdf(x, xw=None):\\n\\n if xw is None:\\n xw = np.ones(len(x))\\n\\n w_sum = xw.sum()\\n\\n if w_sum <= 0:\\n raise ValueError(\\\"Normalisation of weights should be positive, is: \\\",\\n w_sum)\\n\\n # Sort if not sorted\\n if not (np.diff(x) >= 0).all():\\n idx = np.argsort(x)\\n\\n try:\\n x = x.iloc[idx]\\n except AttributeError:\\n x = x[idx]\\n try:\\n xw = xw.iloc[idx]\\n except AttributeError:\\n xw = xw[idx]\\n\\n # Accumulate weights\\n m = np.vstack(((-np.inf, 0), # required for values < min(x)\\n np.column_stack((x, np.cumsum(xw / w_sum)))))\\n\\n # Return a function which gives the value of the ECDF at a given x\\n # (vectoried for array-like objects!)\\n return lambda v: m[np.searchsorted(m[:, 0], v, side=\\\"right\\\") - 1, 1]\",\n \"def func(x, f, fp):\\n\\n return np.sqrt((1+fp(x)**2) / (2 * g * f(x)))\",\n \"def unitary_Gauss(x, center, FWHM):\\n \\n sigma = np.abs(FWHM) /( 2 * np.sqrt(2 * np.log(2)) );\\n Amp = 1.0 / (sigma*np.sqrt(2*np.pi))\\n tau = -((x - center)**2) / (2*(sigma**2))\\n result = Amp * np.exp( tau );\\n \\n return result\",\n \"def fn(self, x):\\n\\n return math.exp(x*2) - math.exp(x) - 2\",\n \"def fn(self, x):\\n\\n return math.exp(x*2) - math.exp(x) - 2\",\n \"def fix_rand_value(lo_bound: float, up_bound: float) -> float:\\n # In this patch test function for determinism, just return lower bound\\n nonlocal _i, _vals_sequence\\n v_return = _vals_sequence[_i]\\n _i = (_i + 1) % len(_vals_sequence)\\n return v_return\",\n \"def pchisq(x, df):\\n \\n if df % 2 == 0:\\n dchi = 0.5 * math.exp(-0.5 * x)\\n f = 1.0 - 2.0 * dchi\\n for i in range(4, df + 1, 2):\\n dchi *= x / (i - 2)\\n f -= 2.0 * dchi\\n \\n else:\\n f = 2.0 * pnorm(math.sqrt(x), 0.0, 1.0) - 1.0\\n dchi = math.exp(-0.5 * x) / math.sqrt(2.0 * math.pi * x)\\n for i in range(3, df + 1, 2):\\n dchi *= x / (i - 2)\\n f -= 2.0 * dchi\\n \\n return f\",\n \"def _call(self, x):\\n if self.prior is None:\\n tmp = -1.0 * (np.log(1 - x)).inner(self.domain.one())\\n else:\\n tmp = (-self.prior * np.log(1 - x)).inner(self.domain.one())\\n if np.isnan(tmp):\\n # In this case, some element was larger than or equal to one\\n return np.inf\\n else:\\n return tmp\",\n \"def empirical_distribution(data, x, n):\\n i = 0\\n while i < n and data[i] <= x:\\n i+=1\\n return float(i)/n\",\n \"def cdfFunction(f, x, N):\\r\\n return ssstats.binom.cdf(x, N, f)\",\n \"def cdf(self,x):\\n if self.base == 'natural':\\n cdfValue = (math.log(x)-self.lowerBound)/(self.upperBound-self.lowerBound)\\n else:\\n cdfValue = (math.log10(x)-self.lowerBound)/(self.upperBound-self.lowerBound)\\n return cdfValue\",\n \"def pofd(self):\\n return self.table[0, 1] / (self.table[0, 1] + self.table[1, 1])\",\n \"def f(x):\\n return delta_eps_mu(x, mu) - delta\",\n \"def gaussian_cdf(x, _erf=erf):\\n return (1 + _erf(x / math.sqrt(2))) / 2\",\n \"def gauss_term_fn(iteration_count, v, z):\\n return tf.math.square(z) / 4. / (\\n (v + iteration_count - 1) * (v + iteration_count))\",\n \"def GetValue(self, *args):\\n return _ITKCostFunctionsPython.itkCumulativeGaussianCostFunction_GetValue(self, *args)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5741531","0.5684328","0.5653153","0.5638879","0.55996156","0.5574182","0.55577606","0.5529009","0.5514495","0.5494531","0.5486149","0.547287","0.54722273","0.54658103","0.54658103","0.5454037","0.54514307","0.5434385","0.54310715","0.54193836","0.5412023","0.53923243","0.5388879","0.5382239","0.538049","0.5380294","0.53758085","0.53752023","0.5374015","0.5369597","0.53579956","0.53514105","0.53508687","0.5342645","0.5341682","0.53318626","0.5328666","0.532576","0.5321431","0.53212374","0.5311811","0.53100216","0.5305999","0.5298435","0.5297973","0.5292103","0.52877665","0.5279043","0.5266763","0.52665794","0.52634543","0.5261696","0.52601373","0.524848","0.5246909","0.5245805","0.5245655","0.5244632","0.52437973","0.52369547","0.5222058","0.52211446","0.5211548","0.52086127","0.52027726","0.52000713","0.5198867","0.5197203","0.51960725","0.51941645","0.51801527","0.5172761","0.5165359","0.5164537","0.5163882","0.5160373","0.51587045","0.5158473","0.5154113","0.5149438","0.51471233","0.51468694","0.51462805","0.5142483","0.51371855","0.51335937","0.5133331","0.51303273","0.5123021","0.5123021","0.512267","0.51223356","0.5119944","0.5117659","0.51163465","0.51143104","0.5112391","0.5111904","0.51118666","0.51103354","0.5104737"],"string":"[\n \"0.5741531\",\n \"0.5684328\",\n \"0.5653153\",\n \"0.5638879\",\n \"0.55996156\",\n \"0.5574182\",\n \"0.55577606\",\n \"0.5529009\",\n \"0.5514495\",\n \"0.5494531\",\n \"0.5486149\",\n \"0.547287\",\n \"0.54722273\",\n \"0.54658103\",\n \"0.54658103\",\n \"0.5454037\",\n \"0.54514307\",\n \"0.5434385\",\n \"0.54310715\",\n \"0.54193836\",\n \"0.5412023\",\n \"0.53923243\",\n \"0.5388879\",\n \"0.5382239\",\n \"0.538049\",\n \"0.5380294\",\n \"0.53758085\",\n \"0.53752023\",\n \"0.5374015\",\n \"0.5369597\",\n \"0.53579956\",\n \"0.53514105\",\n \"0.53508687\",\n \"0.5342645\",\n \"0.5341682\",\n \"0.53318626\",\n \"0.5328666\",\n \"0.532576\",\n \"0.5321431\",\n \"0.53212374\",\n \"0.5311811\",\n \"0.53100216\",\n \"0.5305999\",\n \"0.5298435\",\n \"0.5297973\",\n \"0.5292103\",\n \"0.52877665\",\n \"0.5279043\",\n \"0.5266763\",\n \"0.52665794\",\n \"0.52634543\",\n \"0.5261696\",\n \"0.52601373\",\n \"0.524848\",\n \"0.5246909\",\n \"0.5245805\",\n \"0.5245655\",\n \"0.5244632\",\n \"0.52437973\",\n \"0.52369547\",\n \"0.5222058\",\n \"0.52211446\",\n \"0.5211548\",\n \"0.52086127\",\n \"0.52027726\",\n \"0.52000713\",\n \"0.5198867\",\n \"0.5197203\",\n \"0.51960725\",\n \"0.51941645\",\n \"0.51801527\",\n \"0.5172761\",\n \"0.5165359\",\n \"0.5164537\",\n \"0.5163882\",\n \"0.5160373\",\n \"0.51587045\",\n \"0.5158473\",\n \"0.5154113\",\n \"0.5149438\",\n \"0.51471233\",\n \"0.51468694\",\n \"0.51462805\",\n \"0.5142483\",\n \"0.51371855\",\n \"0.51335937\",\n \"0.5133331\",\n \"0.51303273\",\n \"0.5123021\",\n \"0.5123021\",\n \"0.512267\",\n \"0.51223356\",\n \"0.5119944\",\n \"0.5117659\",\n \"0.51163465\",\n \"0.51143104\",\n \"0.5112391\",\n \"0.5111904\",\n \"0.51118666\",\n \"0.51103354\",\n \"0.5104737\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":87190,"cells":{"query":{"kind":"string","value":"Update distribution functions with this boundary condition."},"document":{"kind":"string","value":"def update(self, ff, **kwargs):\n from .symbolic import call_genfunction\n\n args = self._get_args(ff)\n args.update(kwargs)\n call_genfunction(self.function, args) # pylint: disable=no-member"},"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 update(self, function_values, es, bounds=None):\r\n if bounds is None:\r\n bounds = self.bounds\r\n if bounds is None or (bounds[0] is None and bounds[1] is None): # no bounds ==> no penalty\r\n return self # len(function_values) * [0.0] # case without voilations\r\n\r\n N = es.N\r\n ### prepare\r\n # compute varis = sigma**2 * C_ii\r\n varis = es.sigma**2 * array(N * [es.C] if np.isscalar(es.C) else ( # scalar case\r\n es.C if np.isscalar(es.C[0]) else # diagonal matrix case\r\n [es.C[i][i] for i in xrange(N)])) # full matrix case\r\n\r\n # dmean = (es.mean - es.gp.into_bounds(es.mean)) / varis**0.5\r\n dmean = (es.mean - es.gp.geno(es.gp.into_bounds(es.gp.pheno(es.mean)))) / varis**0.5\r\n\r\n ### Store/update a history of delta fitness value\r\n fvals = sorted(function_values)\r\n l = 1 + len(fvals)\r\n val = fvals[3*l // 4] - fvals[l // 4] # exact interquartile range apart interpolation\r\n val = val / np.mean(varis) # new: val is normalized with sigma of the same iteration\r\n # insert val in history\r\n if np.isfinite(val) and val > 0:\r\n self.hist.insert(0, val)\r\n elif val == inf and len(self.hist) > 1:\r\n self.hist.insert(0, max(self.hist))\r\n else:\r\n pass # ignore 0 or nan values\r\n if len(self.hist) > 20 + (3*N) / es.popsize:\r\n self.hist.pop()\r\n\r\n ### prepare\r\n dfit = np.median(self.hist) # median interquartile range\r\n damp = min(1, es.sp.mueff/10./N)\r\n\r\n ### set/update weights\r\n # Throw initialization error\r\n if len(self.hist) == 0:\r\n raise _Error('wrongful initialization, no feasible solution sampled. ' +\r\n 'Reasons can be mistakenly set bounds (lower bound not smaller than upper bound) or a too large initial sigma0 or... ' +\r\n 'See description of argument func in help(cma.fmin) or an example handling infeasible solutions in help(cma.CMAEvolutionStrategy). ')\r\n # initialize weights\r\n if (dmean.any() and (not self.weights_initialized or es.countiter == 2)): # TODO\r\n self.gamma = array(N * [2*dfit])\r\n self.weights_initialized = True\r\n # update weights gamma\r\n if self.weights_initialized:\r\n edist = array(abs(dmean) - 3 * max(1, N**0.5/es.sp.mueff))\r\n if 1 < 3: # this is better, around a factor of two\r\n # increase single weights possibly with a faster rate than they can decrease\r\n # value unit of edst is std dev, 3==random walk of 9 steps\r\n self.gamma *= exp((edist>0) * np.tanh(edist/3) / 2.)**damp\r\n # decrease all weights up to the same level to avoid single extremely small weights\r\n # use a constant factor for pseudo-keeping invariance\r\n self.gamma[self.gamma > 5 * dfit] *= exp(-1./3)**damp\r\n # self.gamma[idx] *= exp(5*dfit/self.gamma[idx] - 1)**(damp/3)\r\n elif 1 < 3 and (edist>0).any(): # previous method\r\n # CAVE: min was max in TEC 2009\r\n self.gamma[edist>0] *= 1.1**min(1, es.sp.mueff/10./N)\r\n # max fails on cigtab(N=12,bounds=[0.1,None]):\r\n # self.gamma[edist>0] *= 1.1**max(1, es.sp.mueff/10./N) # this was a bug!?\r\n # self.gamma *= exp((edist>0) * np.tanh(edist))**min(1, es.sp.mueff/10./N)\r\n else: # alternative version, but not better\r\n solutions = es.pop # this has not been checked\r\n r = self.feasible_ratio(solutions) # has to be the averaged over N iterations\r\n self.gamma *= exp(np.max([N*[0], 0.3 - r], axis=0))**min(1, es.sp.mueff/10/N)\r\n es.more_to_write += list(self.gamma) if self.weights_initialized else N * [1.0]\r\n ### return penalty\r\n # es.more_to_write = self.gamma if not np.isscalar(self.gamma) else N*[1]\r\n return self # bound penalty values\r","def initializeDistribution(self):\n if (self.lowerBoundUsed == False and self.upperBoundUsed == False):\n self._distribution = distribution1D.BasicWeibullDistribution(self.k,self.lambdaVar,self.low)\n self.lowerBound = self.low\n self.upperBound = sys.float_info.max\n else:\n if self.lowerBoundUsed == False:\n self.lowerBound = self.low\n if self.upperBoundUsed == False:\n self.upperBound = sys.float_info.max\n self._distribution = distribution1D.BasicWeibullDistribution(self.k,self.lambdaVar,self.lowerBound,self.upperBound,self.low)","def update_distribution(self):\n for m in range(0, self.document_number, 1):\n for k in range(0, self.topic_number, 1):\n self.document_distribution_over_topic[m][k]+=((self.document_topic_count_matrix[m][k] + self.alpha[k])\n / (self.sum_document_by_topic_count[m] + self.sum_alpha))\n for k in range(0, self.topic_number, 1):\n for v in range(0, self.term_number,1):\n self.topic_distribution_over_term[k][v] += ((self.topic_term_count_matrix[k][v] + self.beta[v]) / \\\n (self.sum_topic_by_term_count[k] + self.sum_beta))\n # the number of times that the distributions are updated.\n self.update_number += 1","def update(self):\n ## Initialize\n self.domain.update()\n self.var = self.domain.var.copy()\n self.out = []\n\n ## Construct var and out, respecting DAG properties\n for fun in self.functions:\n self.var = list(set(self.var).union(set(fun.var).difference(set(self.out))))\n\n self.out = list(set(self.out).union(set(fun.out)))\n\n try:\n self.var_rand = list(self.density.marginals.keys())\n except AttributeError:\n self.var_rand = []\n self.var_det = list(set(self.var).difference(self.var_rand))\n\n ## TODO parameters\n\n ## Convenience constants\n self.n_var = len(self.var)\n self.n_var_rand = len(self.var_rand)\n self.n_var_det = len(self.var_det)\n self.n_out = len(self.out)","def initializeDistribution(self):\n if (self.lowerBoundUsed == False and self.upperBoundUsed == False):\n self._distribution = distribution1D.BasicExponentialDistribution(self.lambdaVar,self.low)\n self.lowerBound = self.low\n self.upperBound = sys.float_info.max\n else:\n if self.lowerBoundUsed == False:\n self.lowerBound = self.low\n if self.upperBoundUsed == False:\n self.upperBound = sys.float_info.max\n self._distribution = distribution1D.BasicExponentialDistribution(self.lambdaVar,self.lowerBound,self.upperBound,self.low)","def update_forces(self):\n\n pass","def initializeDistribution(self):\n self.minVal = min(math.exp(self.upperBound),math.exp(self.lowerBound))\n self.maxVal = max(math.exp(self.upperBound),math.exp(self.lowerBound))","def initializeDistribution(self):\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\n self._distribution = distribution1D.BasicLogNormalDistribution(self.mean,self.sigma,self.low)\n self.lowerBound = 0.0\n self.upperBound = sys.float_info.max\n else:\n if self.lowerBoundUsed == False:\n self.lowerBound = self.low\n if self.upperBoundUsed == False:\n self.upperBound = sys.float_info.max\n self._distribution = distribution1D.BasicLogNormalDistribution(self.mean,self.sigma,self.lowerBound,self.upperBound, self.low)","def initializeDistribution(self):\n if self.functionType == 'CDF':\n self._distribution = distribution1D.BasicMultiDimensionalInverseWeight(str(self.dataFilename), self.p,True)\n else:\n self._distribution = distribution1D.BasicMultiDimensionalInverseWeight(str(self.dataFilename), self.p,False)\n self.dimensionality = self._distribution.returnDimensionality()\n self.lowerBound = [self.returnLowerBound(dim) for dim in range(self.dimensionality)]\n self.upperBound = [self.returnUpperBound(dim) for dim in range(self.dimensionality)]","def initializeDistribution(self):\n self.convertToDistrDict['Laguerre'] = self.convertLaguerreToGamma\n self.convertToQuadDict ['Laguerre'] = self.convertGammaToLaguerre\n self.measureNormDict ['Laguerre'] = self.stdProbabilityNorm\n if (not self.upperBoundUsed):\n # and (not self.lowerBoundUsed):\n self._distribution = distribution1D.BasicGammaDistribution(self.alpha,1.0/self.beta,self.low)\n #self.lowerBoundUsed = 0.0\n self.upperBound = sys.float_info.max\n self.preferredQuadrature = 'Laguerre'\n self.preferredPolynomials = 'Laguerre'\n else:\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'Legendre'\n if self.lowerBoundUsed == False:\n a = 0.0\n self.lowerBound = a\n else:\n a = self.lowerBound\n if self.upperBoundUsed == False:\n b = sys.float_info.max\n self.upperBound = b\n else:\n b = self.upperBound\n self._distribution = distribution1D.BasicGammaDistribution(self.alpha,1.0/self.beta,self.low,a,b)","def initializeDistribution(self):\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\n self._distribution = distribution1D.BasicLogisticDistribution(self.location,self.scale)\n else:\n if self.lowerBoundUsed == False:\n a = -sys.float_info.max\n else:\n a = self.lowerBound\n if self.upperBoundUsed == False:\n b = sys.float_info.max\n else:\n b = self.upperBound\n self._distribution = distribution1D.BasicLogisticDistribution(self.location,self.scale,a,b)","def initializeDistribution(self):\n self.convertToDistrDict['Jacobi'] = self.convertJacobiToBeta\n self.convertToQuadDict ['Jacobi'] = self.convertBetaToJacobi\n self.measureNormDict ['Jacobi'] = self.stdProbabilityNorm\n #this \"if\" section can only be called if distribution not generated using readMoreXML\n if (not self.upperBoundUsed) and (not self.lowerBoundUsed):\n self._distribution = distribution1D.BasicBetaDistribution(self.alpha,self.beta,self.high-self.low,self.low)\n else:\n if self.lowerBoundUsed == False:\n a = 0.0\n else:\n a = self.lowerBound\n if self.upperBoundUsed == False:\n b = sys.float_info.max\n else:\n b = self.upperBound\n self._distribution = distribution1D.BasicBetaDistribution(self.alpha,self.beta,self.high-self.low,a,b,self.low)\n self.preferredPolynomials = 'Jacobi'\n self.compatibleQuadrature.append('Jacobi')\n self.compatibleQuadrature.append('ClenshawCurtis')","def updateBeta(self):\n\n priorBeta = np.copy(self.beta) # 返り値で更新幅を与えるので初期値を保持しておく\n W = self.__genW() # diag Matrix\n # update beta : Fisher Scoring Update\n result = np.matmul(np.matmul(self.X.T, W), self.X)\n result = np.matmul(np.linalg.inv(result), self.X.T)\n result = np.matmul(result, W)\n # claimFreq=0の人は, firstIterationでmu=0の0割が必ず発生する. 適切な対処法は+epsilonで良い?\n z = (self.Y - self.mu)/(self.mu + DoubleGLM.EPSILON) + np.log(self.mu + DoubleGLM.EPSILON)\n self.beta = np.matmul(result, z)\n\n # update current mu\n self.mu = np.exp(np.matmul(self.X, self.beta))\n # update current deviance\n d1 = self.Y * (self.Y**(1-self.p) - self.mu**(1-self.p)) / (1-self.p)\n d2 = (self.Y**(2-self.p) - self.mu**(2-self.p)) / (2-self.p)\n self.d = 2*self.w * (d1 - d2)\n\n return np.abs(priorBeta - self.beta)","def initializeDistribution(self):\n self.convertToDistrDict['Legendre'] = self.convertLegendreToUniform\n self.convertToQuadDict ['Legendre'] = self.convertUniformToLegendre\n self.measureNormDict ['Legendre'] = self.stdProbabilityNorm\n self.convertToDistrDict['ClenshawCurtis'] = self.convertLegendreToUniform\n self.convertToQuadDict ['ClenshawCurtis'] = self.convertUniformToLegendre\n self.measureNormDict ['ClenshawCurtis'] = self.stdProbabilityNorm\n self._distribution = distribution1D.BasicUniformDistribution(self.lowerBound,self.lowerBound+self.range)","def bayesian_update(self):\n for p in self.parameters:\n p.bayesian_update()","def update(self, es, function_values, **kwargs):\n # On the linear function, the two mirrored samples lead\n # to a sharp increase of the condition of the covariance matrix,\n # unless we have negative weights (which we have now by default).\n # Otherwise they should not be used to update the covariance\n # matrix, if the step-size inreases quickly.\n if self.initialized is not True: # try again\n self.initialize(es.N, es.opts)\n if self.initialized is not True:\n utils.print_warning(\"dimension not known, damping set to 4\",\n 'update', 'CMAAdaptSigmaTPA')\n self.initialized = True\n if 1 < 3:\n f_vals = np.asarray(function_values)\n z = np.sum(f_vals < f_vals[1]) - np.sum(f_vals < f_vals[0])\n z /= len(f_vals) - 1 # z in [-1, 1]\n elif 1 < 3:\n # use the ranking difference of the mirrors for adaptation\n # damp = 5 should be fine\n z = np.nonzero(es.fit.idx == 1)[0][0] - np.nonzero(es.fit.idx == 0)[0][0]\n z /= es.popsize - 1 # z in [-1, 1]\n self.s = (1 - self.sp.c) * self.s + self.sp.c * np.sign(z) * np.abs(z)**self.sp.z_exponent\n if self.s > 0:\n es.sigma *= np.exp(self.s / self.sp.dampup)\n else:\n es.sigma *= np.exp(self.s / self.sp.dampdown)\n #es.more_to_write.append(10**z)","def update(self, X, Y, basisfunc=None):\n\n # Initialise algorithm on first call to update. This allows the\n # algorithm to configure itself to the size of the first input/output\n # data if no hyper-parameters have been specified.\n if not self.__initialised:\n init_basis = self.__basisfunc if basisfunc is None else basisfunc\n x = init_basis(X)\n m = x.shape[1] if np.ndim(x) > 1 else X.size\n n = Y.shape[1] if np.ndim(Y) > 1 else Y.size\n self.__initialise_algorithm(m, n)\n self.__initialised = True\n\n # Get size of data.\n k = X.shape[0] if np.ndim(X) > 1 else X.size\n m, n = self.__m, self.__n\n\n # Allocate variables for the dynamic programming pass.\n loglik = -np.inf\n logmax = -np.inf\n logsum = -np.inf\n ind = np.nan\n\n # Update hypotheses by updating each matrix variate, normal inverse\n # gamma distribution over the linear models.\n for hypothesis in self.__hypotheses:\n\n # Update the sufficient statistics.\n hypothesis['distribution'].update(hypothesis['basisfunc'](X), Y)\n\n # Compute the log-normalization constant after the update\n # (posterior parameter distribution).\n # (Equation 8)\n n_o = hypothesis['log_constant']\n n_k = hypothesis['log_constant'] = hypothesis['distribution'].log_constant()\n\n # Evaluate the log-density of the predictive distribution.\n # (Equation 16)\n log_density = n_k - n_o - k * (0.5 * m * n) * np.log(2.0 * np.pi)\n\n # Increment the counter.\n hypothesis['count'] += 1\n\n # Accumulate the log-likelihood of the data.\n # (Equation 17)\n hazard = self.__ratefun(hypothesis['count'])\n aux = np.log(hazard) + log_density + hypothesis['log_probability']\n loglik = self.__soft_max(loglik, aux)\n\n # Keep track of the highest, log-likelihood.\n if aux > logmax:\n logmax, ind = aux, hypothesis['count']\n\n # Update and accumulate the log-probabilities.\n hypothesis['log_probability'] += np.log1p(-hazard) + log_density\n logsum = self.__soft_max(logsum, hypothesis['log_probability'])\n\n # In the max-product algorithm, keep track of the most likely\n # hypotheses.\n if self.__alg__ == 'maxprod':\n loglik = logmax\n self.__counts.append(ind)\n\n # Add a new hypothesis, which states that the next segment is about to\n # begin.\n self.__add_new_hypothesis(loglik, basisfunc)\n\n # Normalize the hypotheses so that their probabilities sum to one.\n logsum = self.__soft_max(logsum, loglik)\n for hypothesis in self.__hypotheses:\n hypothesis['log_probability'] -= logsum\n\n # Automatically trim hypothesis on each update if requested.\n if self.__maximum_hypotheses is not None:\n self.trim_hypotheses(minprob=self.__minimum_probability,\n maxhypot=self.__maximum_hypotheses)\n\n # In the sum-product algorithm, keep track of the probabilities.\n if self.__alg__ == 'sumprod':\n iteration = list()\n for hypothesis in self.__hypotheses:\n iteration.append((hypothesis['count'],\n hypothesis['log_probability']))\n\n self.__probabilities.append(iteration)","def __init__(self):\n super().__init__()\n self.upperBoundUsed = False # True if the distribution is right truncated\n self.lowerBoundUsed = False # True if the distribution is left truncated\n self.hasInfiniteBound = False # True if the untruncated distribution has bounds of +- system max\n self.upperBound = None # Right bound\n self.lowerBound = None # Left bound\n self.__adjustmentType = '' # this describe how the re-normalization to preserve the probability should be done for truncated distributions\n self.dimensionality = None # Dimensionality of the distribution (1D or ND)\n self.distType = None # Distribution type (continuous or discrete)\n self.memory = False # This variable flags if the distribution has history dependence in the sampling process (True) or not (False)\n self.printTag = 'DISTRIBUTIONS'\n self.preferredPolynomials = None # best polynomial for probability-weighted norm of error\n self.preferredQuadrature = None # best quadrature for probability-weighted norm of error\n self.compatibleQuadrature = [] #list of compatible quadratures\n self.convertToDistrDict = {} #dict of methods keyed on quadrature types to convert points from quadrature measure and domain to distribution measure and domain\n self.convertToQuadDict = {} #dict of methods keyed on quadrature types to convert points from distribution measure and domain to quadrature measure and domain\n self.measureNormDict = {} #dict of methods keyed on quadrature types to provide scalar adjustment for measure transformation (from quad to distr)\n self.convertToDistrDict['CDFLegendre'] = self.CDFconvertToDistr\n self.convertToQuadDict ['CDFLegendre'] = self.CDFconvertToQuad\n self.measureNormDict ['CDFLegendre'] = self.CDFMeasureNorm\n self.convertToDistrDict['CDFClenshawCurtis'] = self.CDFconvertToDistr\n self.convertToQuadDict ['CDFClenshawCurtis'] = self.CDFconvertToQuad\n self.measureNormDict ['CDFClenshawCurtis'] = self.CDFMeasureNorm","def initializeDistribution(self):\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\n self._distribution = distribution1D.BasicGeometricDistribution(self.p)\n else: self.raiseAnError(IOError,'Truncated Geometric not yet implemented')","def initializeDistribution(self):\n\n f = open(self.dataFilename, 'r')\n reader = csv.reader(f)\n headers = next(reader)\n indexFunctionID = headers.index(self.functionID)\n indexVariableID = headers.index(self.variableID)\n f.close()\n rawData = np.genfromtxt(self.dataFilename, delimiter=\",\" , skip_header=1, usecols=(indexVariableID,indexFunctionID))\n\n self.data = rawData[rawData[:,0].argsort()]\n self.lowerBound = self.data[0,0]\n self.upperBound = self.data[-1,0]\n\n if self.functionType == 'cdf':\n self.cdfFunc = UnivariateSpline(self.data[:,0], self.data[:,1], k=self.k, s=self.s)\n self.pdfFunc = self.cdfFunc.derivative()\n self.invCDF = UnivariateSpline(self.data[:,1], self.data[:,0], k=self.k, s=self.s)\n else:\n self.pdfFunc = UnivariateSpline(self.data[:,0], self.data[:,1], k=self.k, s=self.s)\n cdfValues = np.zeros(self.data[:,0].size)\n for i in range(self.data[:,0].size):\n cdfValues[i] = self.pdfFunc.integral(self.data[0][0],self.data[i,0])\n self.invCDF = UnivariateSpline(cdfValues, self.data[:,0] , k=self.k, s=self.s)\n\n # Note that self.invCDF is creating a new spline where I switch its term.\n # Instead of doing spline(x,f(x)) I am creating its inverse spline(f(x),x)\n # This can be done if f(x) is monothonic increasing with x (which is true for cdf)","def update_forces(self):\r\n # update all the functions\r\n self.compute_gravity()\r\n self.compute_tides()\r\n self.compute_centrifugal()\r\n self.compute_coriolis()\r\n\r\n # add together the forces into the summation function\r\n self.forcing.assign(self.ftides+self.gravity +\r\n self.centrifugal+self.coriolis)","def update(self):\n self._g, self._B = self._constraint_assembler.preallocate_g_and_B(self._no_of_dofs_unconstrained,\n self._dofidxs(),\n self._no_of_constraints_by_object())","def initializeDistribution(self):\n if self.lowerBoundUsed == False:\n self.lowerBound = -sys.float_info.max\n if self.upperBoundUsed == False:\n self.upperBound = sys.float_info.max\n self._distribution = distribution1D.BasicLaplaceDistribution(self.location,self.scale,self.lowerBound,self.upperBound)","def update(self, space: Space, function: Function) -> None:\n\n self._local_seeding(space, function)\n candidate = self._population_limiting(space)\n self._global_seeding(space, function, candidate)\n\n space.agents, self.age = map(\n list, zip(*sorted(zip(space.agents, self.age), key=lambda x: x[0].fit))\n )\n\n self.age[0] = 0","def _update_ps(self, es):\n if not self.is_initialized_base:\n self.initialize_base(es)\n if self._ps_updated_iteration == es.countiter:\n return\n try:\n if es.countiter <= es.sm.itereigenupdated:\n # es.B and es.D must/should be those from the last iteration\n utils.print_warning('distribution transformation (B and D) have been updated before ps could be computed',\n '_update_ps', 'CMAAdaptSigmaBase', verbose=es.opts['verbose'])\n except AttributeError:\n pass\n z = es.sm.transform_inverse((es.mean - es.mean_old) / es.sigma_vec.scaling)\n # assert Mh.vequals_approximately(z, np.dot(es.B, (1. / es.D) *\n # np.dot(es.B.T, (es.mean - es.mean_old) / es.sigma_vec.scaling)))\n z *= es.sp.weights.mueff**0.5 / es.sigma / es.sp.cmean\n self.ps = (1 - self.cs) * self.ps + (self.cs * (2 - self.cs))**0.5 * z\n self._ps_updated_iteration = es.countiter","def update(self, applyTo='global', conditions='True', param=\"None\"):\n super(NeumannBoundary, self).update(applyTo, conditions, \"None\")","def initializeDistribution(self):\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\n self._distribution = distribution1D.BasicPoissonDistribution(self.mu)\n self.lowerBound = 0.0\n self.upperBound = sys.float_info.max\n else:\n self.raiseAnError(IOError,'Truncated poisson not yet implemented')","def updateDistribution(self, PD, bestSh):\n #* Here bestSh is a dictionary as saved in self.Data\n del self.Data[bestSh['Pat'].prev_order]\n out = PD.lprevUpdate.pop(bestSh['Pat'].prev_order, None)\n if not out:\n print('Something is fishy')\n else:\n la = PD.updateDistribution( bestSh['SPat'].G, idx=bestSh['SPat'].cur_order, val_return='save', case=2 )\n bestSh['SPat'].setLambda(la)\n return","def updateRanges(self):\n # work directly on the histograms, no copy\n for i in range(len(self)):\n self[i].updateRange()","def variational_update(self):\n with self.elbo_check('update_p_allele_swap'):\n self.model.update_p_allele_swap()\n\n with self.elbo_check('p_cn'):\n self.model.update_p_cn()\n\n with self.elbo_check('p_breakpoint'):\n self.model.update_p_breakpoint()\n\n with self.elbo_check('p_outlier_total'):\n self.model.update_p_outlier_total()\n\n with self.elbo_check('p_outlier_allele'):\n self.model.update_p_outlier_allele()","def prob_update(self):\n pass","def initializeDistribution(self):\n self.checkDistParams()\n\n self.lowerBound = min(self.mapping.keys())\n self.upperBound = max(self.mapping.keys())","def FB(self):\n # The maximum update amount for these element\n StepLength_DELTA = self.dt * (self.StepLength_LIMITS[1] -\n self.StepLength_LIMITS[0]) / (6.0)\n StepVelocity_DELTA = self.dt * (self.StepVelocity_LIMITS[1] -\n self.StepVelocity_LIMITS[0]) / (2.0)\n\n # Add either positive or negative or zero delta for each\n # NOTE: 'High' is open bracket ) so the max is 1\n if self.StepLength < -self.StepLength_LIMITS[0] / 2.0:\n StepLength_DIRECTION = np.random.randint(-1, 3, 1)[0]\n elif self.StepLength > self.StepLength_LIMITS[1] / 2.0:\n StepLength_DIRECTION = np.random.randint(-2, 2, 1)[0]\n else:\n StepLength_DIRECTION = np.random.randint(-1, 2, 1)[0]\n StepVelocity_DIRECTION = np.random.randint(-1, 2, 1)[0]\n\n # Now, modify modifiable params AND CLIP\n self.StepLength += StepLength_DIRECTION * StepLength_DELTA\n self.StepLength = np.clip(self.StepLength, self.StepLength_LIMITS[0],\n self.StepLength_LIMITS[1])\n self.StepVelocity += StepVelocity_DIRECTION * StepVelocity_DELTA\n self.StepVelocity = np.clip(self.StepVelocity,\n self.StepVelocity_LIMITS[0],\n self.StepVelocity_LIMITS[1])","def _update_parameter(self, dWxh, dbh, dWhy, dby):\n # Add code to update all the weights and biases here","def update(self, es, **kwargs):\n es.sigma = self.coefficient * es.sp.weights.mueff * _norm(es.mean) / es.N / es.sp.cmean","def _modify_updates(self, updates):\n\n if self.max_kernel_norm is not None:\n W, = self.transformer.get_params()\n if W in updates:\n updated_W = updates[W]\n row_norms = T.sqrt(T.sum(T.sqr(updated_W), axis=(0, 1, 2)))\n desired_norms = T.clip(row_norms, 0, self.max_kernel_norm)\n scales = desired_norms / (1e-7 + row_norms)\n updates[W] = (updated_W * scales.dimshuffle('x', 'x', 'x', 0))","def _update_distribution(self, trajectories):\n costs = trajectories[\"costs\"].copy()\n actions = trajectories[\"actions\"].copy()\n Q = cost_to_go(costs, self.gamma_seq)\n best_id = np.argmin(Q, axis = 0)[0]\n self.mean_action = (1.0 - self.step_size) * self.mean_action +\\\n self.step_size * actions[best_id]","def update_r(self):\n self.gamma_r = self.gamma_s - self.gamma_q\n self.Sigma_r = self.Sigma_s - self.Sigma_q","def _update_(self):\n self._update_distance_()\n self._check_literature_name_()","def initializeDistribution(self):\n self.raiseAMessage('initialize distribution')\n mu = distribution1D.vectord_cxx(len(self.mu))\n for i in range(len(self.mu)):\n mu[i] = self.mu[i]\n covariance = distribution1D.vectord_cxx(len(self.covariance))\n for i in range(len(self.covariance)):\n covariance[i] = self.covariance[i]\n if self.method == 'spline':\n if self.covarianceType != 'abs':\n self.raiseAnError(IOError,'covariance with type ' + self.covariance + ' is not implemented for ' + self.method + ' method')\n self._distribution = distribution1D.BasicMultivariateNormal(covariance, mu)\n elif self.method == 'pca':\n self._distribution = distribution1D.BasicMultivariateNormal(covariance, mu, str(self.covarianceType), self.rank)\n if self.transformation:\n self.lowerBound = [-sys.float_info.max]*self.rank\n self.upperBound = [sys.float_info.max]*self.rank\n else:\n self.lowerBound = [self.returnLowerBound(dim) for dim in range(self.dimension)]\n self.upperBound = [self.returnUpperBound(dim) for dim in range(self.dimension)]","def update(self, values, weights):\n super().update(values)","def update(self, values, weights):\n super().update(values)","def update(self, values, weights):\n super().update(values)","def update(self, values, weights):\n super().update(values)","def update(self):\n # Update the weight matrix: \n self.W -= self.lr * self.grad_W \n \n # Update the bias matrices:\n self.b -= self.lr * np.array(self.grad_b) \n self.c -= self.lr * np.array(self.grad_c)","def update_policy(self):\n self.optimizer.step()\n self.optimizer.zero_grad()","def update(self):\n for p in self.persons:\n p.update(self.max_step)\n if p.state == State.INFECTED:\n for other in self.persons:\n if np.linalg.norm(p.position - other.position) < self.infection_radius and id(p) != id(other):\n if other.state == State.HEALTHY:\n other.state = random.choices(\n list(State), weights=[0.0, 1.0, 0, 0])[0]\n elif other.state == State.RECOVERED:\n other.state = random.choices(\n list(State), weights=[0, 0.1, 0.8, 0])[0]","def get_distribution(self):\n\n # If the distributions have been updated before.\n if self.update_number > 0:\n for m in range(0, self.document_number, 1):\n for k in range(0, self.topic_number,1):\n probability = self.document_distribution_over_topic[m][k] / self.update_number\n self.document_distribution_over_topic[m][k] = probability\n for k in range(0, self.topic_number,1):\n for v in range(0, self.term_number,1):\n probability = self.topic_distribution_over_term[k][v] / self.update_number\n self.topic_distribution_over_term[k][v] = probability\n # The distributions have not been updated once.\n else:\n for m in range(0, self.document_number, 1):\n for k in range(0, self.topic_number, 1):\n self.document_distribution_over_topic[m][k] = (\n (self.document_topic_count_matrix[m][k] + self.alpha[k]) / (\n self.sum_document_by_topic_count[m] + self.sum_alpha))\n for k in range(0, self.topic_number, 1):\n for v in range(0, self.term_number, 1):\n self.topic_distribution_over_term[k][v] = (\n (self.topic_term_count_matrix[k][v] + self.beta[v]) / (\n self.sum_topic_by_term_count[k] + self.sum_beta))","def update_focal_axes(self):\n self.update_sigma()\n self.updateGL()","def update_parameters(self):\n # We update gamma, gamma0, lambda and nu in turn (Bottolo et al, 2011)\n self.update_gamma()\n self.update_gamma0()\n self.update_lambda()\n self.update_nu()\n if self.sample_xi:\n self.update_xi()","def _update_parameters(self, curr_state, reward, next_state):\n phi = self._features.vector(curr_state)\n phi_dash = self._features.vector(next_state)\n\n self._A += np.outer(phi, (phi - self._gamma * phi_dash))\n self._b += reward * phi","def _distributed_apply(self, distribution, grads_hessian_and_vars, name, apply_state):\n\n def apply_grad_to_update_var(var, grad, hess):\n \"\"\"Apply gradient to variable.\"\"\"\n if isinstance(var, ops.Tensor):\n raise NotImplementedError(\"Trying to update a Tensor \", var)\n\n apply_kwargs = {}\n\n if \"apply_state\" in self._dense_apply_args:\n apply_kwargs[\"apply_state\"] = apply_state\n update_op = self._resource_apply_dense(grad, hess, var, **apply_kwargs)\n\n if var.constraint is not None:\n with ops.control_dependencies([update_op]):\n return var.assign(var.constraint(var))\n else:\n return update_op\n\n eagerly_outside_functions = ops.executing_eagerly_outside_functions()\n update_ops = []\n with ops.name_scope(name or self._name, skip_on_eager=True):\n for grad, hess, var in grads_hessian_and_vars:\n\n def _assume_mirrored(grad, hess):\n if isinstance(grad, ds_values.PerReplica):\n return ds_values.Mirrored(grad.values), ds_values.Mirrored(hess.values)\n return grad, hess\n\n grad, hess = nest.map_structure(_assume_mirrored, grad, hess)\n # Colocate the update with variables to avoid unnecessary communication\n # delays. See b/136304694.\n with distribution.extended.colocate_vars_with(var):\n with ops.name_scope(\"update\" if eagerly_outside_functions else\n \"update_\" + var.op.name, skip_on_eager=True):\n update_ops.extend(distribution.extended.update(\n var, apply_grad_to_update_var, args=(grad, hess), group=False))\n\n any_symbolic = any(isinstance(i, ops.Operation) or\n tf_utils.is_symbolic_tensor(i) for i in update_ops)\n if not context.executing_eagerly() or any_symbolic:\n # If the current context is graph mode or any of the update ops are\n # symbolic then the step update should be carried out under a graph\n # context. (eager updates execute immediately)\n with ops._get_graph_from_inputs(update_ops).as_default(): # pylint: disable=protected-access\n with ops.control_dependencies(update_ops):\n return self._iterations.assign_add(1, read_value=False)\n\n return self._iterations.assign_add(1)","def update_posterior_probs(vars_):\n vars_.weighted_sums += np.power(vars_.dprime_map[vars_.focus],2) * vars_.visual_field\n vars_.post_probs = np.exp(vars_.weighted_sums) * vars_.prior_prob\n vars_.post_probs /= np.sum(vars_.post_probs)","def update(self, dt):\n # get normal random iscipyut\n u = self.prng.normal(size=(1, self._x.shape[1]))\n # calculate state time derivative with state space equation\n dx_dt = self._A.dot(self._x) + self._B * u\n # apply update with Euler integration\n self._x += dx_dt * dt","def initializeDistribution(self):\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\n self._distribution = distribution1D.BasicBinomialDistribution(self.n,self.p)\n else:\n self.raiseAnError(IOError,'Truncated Binomial not yet implemented')","def initializeDistribution(self):\n self.raiseAMessage('initialize Distribution')\n if self.functionType == 'CDF':\n self._distribution = distribution1D.BasicMultiDimensionalCartesianSpline(str(self.dataFilename),True)\n else:\n self._distribution = distribution1D.BasicMultiDimensionalCartesianSpline(str(self.dataFilename),False)\n self.dimensionality = self._distribution.returnDimensionality()\n self.lowerBound = [self.returnLowerBound(dim) for dim in range(self.dimensionality)]\n self.upperBound = [self.returnUpperBound(dim) for dim in range(self.dimensionality)]","def Update(self):\n if self.NAtt > 0:\n self.D *= (self.NAcc / self.NAtt + 0.1) / (self.TargetAcc + 0.1)\n self.D = min(self.MaxD, max(self.MinD, self.D))","def update_throttled(self):\n self.ros_if.update()","def updateFitness(self):\r\n for candidate in self.candidates:\r\n candidate.updateFitness()\r\n return","def initializeDistribution(self):\n self.convertToDistrDict['Hermite'] = self.convertHermiteToNormal\n self.convertToQuadDict ['Hermite'] = self.convertNormalToHermite\n self.measureNormDict ['Hermite'] = self.stdProbabilityNorm\n if (not self.upperBoundUsed) and (not self.lowerBoundUsed):\n self._distribution = distribution1D.BasicNormalDistribution(self.mean,\n self.sigma)\n self.lowerBound = -sys.float_info.max\n self.upperBound = sys.float_info.max\n self.preferredQuadrature = 'Hermite'\n self.preferredPolynomials = 'Hermite'\n else:\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'Legendre'\n if self.lowerBoundUsed == False:\n a = -sys.float_info.max\n self.lowerBound = a\n else:\n a = self.lowerBound\n if self.upperBoundUsed == False:\n b = sys.float_info.max\n self.upperBound = b\n else:\n b = self.upperBound\n self._distribution = distribution1D.BasicNormalDistribution(self.mean,\n self.sigma,\n a,b)","def initializeDistribution(self):\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\n self._distribution = distribution1D.BasicBernoulliDistribution(self.p)\n else:\n self.raiseAnError(IOError,'Truncated Bernoulli not yet implemented')","def update_target(self):\n with torch.no_grad():\n for target_q_param, q_param in zip(self.target_q_funcs.parameters(), self.q_funcs.parameters()):\n target_q_param.data.copy_(self.tau * q_param.data + (1.0 - self.tau) * target_q_param.data)\n for target_pi_param, pi_param in zip(self.target_policy.parameters(), self.policy.parameters()):\n target_pi_param.data.copy_(self.tau * pi_param.data + (1.0 - self.tau) * target_pi_param.data)","def _modify_updates(self, updates):\n wxf = self.wxf\n wyf = self.wyf\n wxf_updated = updates[wxf]\n wyf_updated = updates[wyf]\n nwxf = (wxf_updated.std(0) + SMALL)[numpy.newaxis, :]\n nwyf = (wyf_updated.std(0) + SMALL)[numpy.newaxis, :]\n meannxf = nwxf.mean()\n meannyf = nwyf.mean()\n # Center filters\n centered_wxf = wxf_updated - wxf_updated.mean(0)\n centered_wyf = wyf_updated - wyf_updated.mean(0)\n # Fix standard deviation\n wxf_updated = centered_wxf * (meannxf / nwxf)\n wyf_updated = centered_wyf * (meannyf / nwyf)\n updates[wxf] = wxf_updated\n updates[wyf] = wyf_updated","def apply_fhd(self, gfhd):\n for bl in self.data.keys():\n i,j = bl\n p1,p2 = self.pol\n G = gfhd[p1][i]*gfhd[p2][j].conj()\n ind = np.where(G != 0)[0]\n self.data[bl][self.pol][:,ind] /= G[ind]","def initializeDistribution(self):\n if self.nPoints is None:\n self.xArray = np.arange(self.lowerBound,self.upperBound+1)\n else:\n self.xArray = np.linspace(self.lowerBound,self.upperBound,self.nPoints)\n\n # Here the actual calculation of discrete distribution parameters is performed\n self.pdfArray = 1.0/self.xArray.size * np.ones(self.xArray.size)\n paramsDict={}\n paramsDict['outcome'] = self.xArray\n paramsDict['state'] = self.pdfArray\n\n self.categoricalDist = Categorical()\n self.categoricalDist.initializeFromDict(paramsDict)\n initialPerm = randomUtils.randomPermutation(self.xArray.tolist(),self)\n self.pot = np.asarray(initialPerm)","def update_focal_axes(self):\n #self.update_sigma()\n self.updateGL()","def update_distr_and_return_proba(self, gp_conn=None): \n\n results = self.results_from_db(gp_conn)\n self.arms_probability = dict.fromkeys(self.active_arms)\n\n for i in self.active_arms:\n try:\n self.arms_dict_params[i]['success'].append(results[i]['success'])\n self.arms_dict_params[i]['trials'].append(results[i]['trials'])\n self.arms_dict_params[i]['current_alpha'] += self.arms_dict_params[i]['success'][-1]\n self.arms_dict_params[i]['current_beta'] += self.arms_dict_params[i]['trials'][-1] - \\\n self.arms_dict_params[i]['success'][-1]\n except:\n # вот тут надо рэйзить ошибку\n self.arms_dict_params[i]['success'].append(0)\n self.arms_dict_params[i]['trials'].append(0)\n\n self.arms_probability[i] = random.betavariate(self.arms_dict_params[i]['current_alpha'],\n self.arms_dict_params[i]['current_beta'])\n self.arms_dict_params[i]['probability'].append(self.arms_probability[i])\n\n return self.arms_dict_params, self.arms_probability","def update(\n self, space: Space, function: Function, iteration: int, n_iterations: int\n ) -> None:\n\n mean_position = np.mean([agent.position for agent in space.agents], axis=0)\n\n # Calculates the Sigma Reduction Factor (eq. 5)\n SRF = (-np.log(1 - (1 / np.sqrt(iteration + 2)))) ** 2\n\n # Calculates the Beta Expansion Factor\n BEF = self.beta + (2 - self.beta) * ((iteration + 1) / n_iterations)\n\n for agent in space.agents:\n a = copy.deepcopy(agent)\n\n for j in range(agent.n_variables):\n # Calculates the random walk (eq. 2 and 3)\n random_step = r.generate_gaussian_random_number(mean_position[j], SRF)\n\n # Calculates the Lévy flight (eq. 6 to 18)\n levy_step = d.generate_levy_distribution(BEF)\n\n a.position[j] += (\n random_step\n * levy_step\n * (agent.position[j] - space.best_agent.position[j])\n )\n a.clip_by_bound()\n\n a.fit = function(a.position)\n if a.fit < agent.fit:\n agent.position = copy.deepcopy(a.position)\n agent.fit = copy.deepcopy(a.fit)","def initializeDistribution(self):\n if (self.lowerBoundUsed == False and self.upperBoundUsed == False) or (self.min == self.lowerBound and self.max == self.upperBound):\n self._distribution = distribution1D.BasicTriangularDistribution(self.apex,self.min,self.max)\n else:\n self.raiseAnError(IOError,'Truncated triangular not yet implemented')","def update_probabilities(self):\n self.probabilities = self.pheromones**self.EXP_PH * self.mcv**self.EXP_MCV","def initializeDomainCondition(self):\n print('Initialize the condition.')\n\n self.fluidPDF = np.zeros([self.typesFluids, self.ny, self.nx, 9])\n self.fluidsDensity = np.zeros([self.typesFluids, self.ny, self.nx])\n self.physicalVX = np.zeros([self.ny, self.nx])\n self.physicalVY = np.zeros([self.ny, self.nx])\n self.forceX = np.zeros([self.typesFluids, self.ny, self.nx])\n self.forceY = np.zeros([self.typesFluids, self.ny, self.nx])\n if (self.PictureExistance == \"'no'\"):\n for i in sp.arange(self.ny):\n for j in sp.arange(self.nx):\n# for k in sp.arange(self.typesFluids):\n tmpCenterX = int(self.nx / 2); tmpCenterY = int(self.ny / 2)\n if (self.isDomain[i, j] == True):\n# if (sp.sqrt((i - tmpCenterY) * (i - tmpCenterY) + (j - \\\n# tmpCenterX) * (j - tmpCenterX)) <= 15.):\n# if (i < 15 and np.abs(j - tmpCenterX) < 15):\n# if ((i >0 and i < 28) and (j >=102 and j < 154)):\n if (i < self.ny - 10):\n# if (i < 128 and i > 70):\n self.fluidsDensity[0, i, j] = self.initialDensities[0]\n self.fluidPDF[0, i, j, :] = self.weightsCoeff * self.initialDensities[0]\n self.fluidsDensity[1, i, j] = self.backgroundDensities[1]\n self.fluidPDF[1, i, j, :] = self.weightsCoeff * self.backgroundDensities[1]\n else:\n self.fluidsDensity[1, i, j] = self.initialDensities[1]\n self.fluidPDF[1, i, j, :] = self.weightsCoeff * self.initialDensities[1]\n self.fluidsDensity[0, i, j] = self.backgroundDensities[0]\n self.fluidPDF[0, i, j, :] = self.weightsCoeff * self.backgroundDensities[0] \n \n if (self.isCycles == \"'no'\" and self.PictureExistance == \"'yes'\"):\n for i in sp.arange(self.ny):\n for j in sp.arange(self.nx):\n if (i < self.ny - 20):\n # if ( np.abs(i - 60) < 20):\n for k in sp.arange(self.typesFluids):\n if (k == 0 and self.isDomain[i, j] == 1):\n self.fluidPDF[k, i, j, :] = self.initialDensities[k] * self.weightsCoeff\n self.fluidsDensity[k, i, j] = self.initialDensities[k]\n if (k == 1 and self.isDomain[i, j] == 1):\n self.fluidPDF[k, i, j, :] = self.backgroundDensities[k] * self.weightsCoeff\n self.fluidsDensity[k, i, j] = self.backgroundDensities[k]\n else:\n for k in sp.arange(self.typesFluids):\n if (k == 0 and self.isDomain[i, j] == 1):\n self.fluidPDF[k, i, j, :] = self.backgroundDensities[k] * self.weightsCoeff\n self.fluidsDensity[k, i, j] = self.backgroundDensities[k]\n if (k == 1 and self.isDomain[i, j] == 1):\n self.fluidPDF[k, i, j, :] = self.initialDensities[k] * self.weightsCoeff\n self.fluidsDensity[k, i, j] = self.initialDensities[k]\n elif (self.isCycles == \"'yes'\" and self.PictureExistance == \"'yes'\"):\n username = getpass.getuser()\n pathIniFile = '/home/' + username + '/LBMInitial/'\n if (os.path.exists(pathIniFile) == True): \n #for the old fluid distribution\n #the domain of the network\n iniFile = tb.open_file(pathIniFile + 'SimulationResults.h5', 'r')\n for i in sp.arange(self.typesFluids-1):\n self.fluidsDensity[i, :-30, :] = eval('iniFile.root.FluidMacro.FluidDensityType%gin%d[:-30, :]' % (i, self.lastStep))\n self.fluidsDensity[i, -30:, :] = self.backgroundDensities[i]\n for j in sp.arange(self.ny):\n for k in sp.arange(self.nx):\n self.fluidPDF[i, j, k, :] = self.weightsCoeff * \\\n self.fluidsDensity[i, j, k]\n iniFile.close()\n# for the new fluid in the domain\n for i in sp.arange(self.ny):\n for j in sp.arange(self.nx):\n if (i < self.ny - 30 and self.isDomain[i, j] == 1):\n self.fluidsDensity[-1, i, j] = self.backgroundDensities[-1]\n self.fluidPDF[-1, i, j, :] = self.backgroundDensities[-1] * \\\n self.weightsCoeff\n# continue\n elif (i >= self.ny - 30 and self.isDomain[i, j] == 1):\n self.fluidsDensity[-1, i, j] = self.initialDensities[-1]\n self.fluidPDF[-1, i, j, :] = self.initialDensities[-1] * \\\n self.weightsCoeff\n else:\n print(\"There is no file for initializing the domain.\")\n sys.exit()","def update_total_fpmu_dict(self):\n # identical for each long-range connection\n # extract parameters\n deltat = self.dt\n trise = self.tau_r\n tdamp = self.tau_d\n\n tr = deltat/trise\n etr = np.exp(-tr) \n td = deltat/tdamp\n etd = np.exp(-td)\n cst = trise/(tdamp-trise)\n\n # nmda should keep in memory which could not be reset to zerooooooo!!!\n \"\"\"\n no resetting to zero --> go directly to refreshing !!! based on pre-value\n \"\"\"\n for c in self.source_connection_list:\n if (c.conn_type == 'LongRange'):\n self.total_INMDA_dict[c.connection_distribution] = self.total_INMDA_dict[c.connection_distribution] * etd + self.total_HNMDA_dict[c.connection_distribution] * cst\n self.total_HNMDA_dict[c.connection_distribution] = self.total_HNMDA_dict[c.connection_distribution] * etr + c.curr_firing_rate * c.nsyn * c.weights * self.tau_r\n\n print 'Change HNMDA: ', c.curr_firing_rate * c.nsyn ,' \\n'\n print 'Inputlr dict: ', self.total_inputlr_dict[c.connection_distribution]\n\n\n\n # for curr_CD in self.source_connection_list:\n # have already exist\n for c in self.source_connection_list:\n if(c.conn_type == 'ShortRange'):\n self.total_fpmu_dict[c.connection_distribution] = 0.0\n # have already clear up all the short range connections\n for c in self.source_connection_list:\n if(c.conn_type == 'ShortRange'):\n self.total_fpmu_dict[c.connection_distribution] += c.curr_firing_rate * c.nsyn * c.weights\n\n # summation\n self.total_fp_vslave = 0.0\n for key,val in self.total_fpmu_dict.items():\n \n try:\n self.total_fp_vslave += val\n except:\n key.initialize()\n self.total_fp_vslave += val\n # and then, summation of Inmda\n for key,val in self.total_INMDA_dict.items():\n try:\n self.total_fp_vslave += val\n except:\n key.initialize()\n self.total_fp_vslave += val\n # and then divided by gL or multiply tau_m\n self.total_fp_vslave = self.total_fp_vslave * self.tau_m","def update_weights(self):\n\t\tpass","def _UpdateCriteria(self):\n grad = self.traj.grad[-1]\n disp = self.traj.coords[-1] - self.traj.coords[-2]\n self.delta_e = self.traj.energy[-1] - self.traj.energy[-2]\n self.grad_max = numpy.amax(grad)\n self.disp_max = numpy.amax(disp)\n self.grad_rms = math.sqrt(numpy.mean(grad**2))\n self.disp_rms = math.sqrt(numpy.mean(disp**2))","def update_weights(self, inputVec, sigma, lrate, bmu):\r\n\r\n dist = self.get_nodeDistance(bmu)\r\n gauss = np.exp(-dist * dist / (2 * sigma * sigma))\r\n if gauss > 0:\r\n for i in range(len(self.weights)):\r\n self.weights[i] = self.weights[i] - gauss * lrate * (self.weights[i] - inputVec[i])","def applyForce(self, F, dT):","def _update(self):\n self.cv.update()","def updateForces(self):\n for atom1 in range(0, self.numAtoms-1):\n for atom2 in range(atom1+1, self.numAtoms):\n self.calculateForce(atom1, atom2)\n \n # Multiply by constants \n for atom in range(0, self.numAtoms):\n self.atoms[atom].fx *= 48*self.e\n self.atoms[atom].fy *= 48*self.e\n self.atoms[atom].fz *= 48*self.e\n self.atoms[atom].potential *= 4*self.e","def update_counts(self, new_alpha, new_beta, decay):\n\n self._alpha = self._alpha / decay + new_alpha\n self._beta = self._beta / decay + new_beta\n self._n_updates += 1","def update(self, es, **kwargs):\n es.sigma *= self.update2(es, **kwargs)\n if 11 < 3:\n # derandomized MSR = natural gradient descent using mean(z**2) instead of mu*mean(z)**2\n fit = kwargs['fit'] # == es.fit\n slengths = np.array([sum(z**2) for z in es.arz[fit.idx[:es.sp.weights.mu]]])\n # print lengths[0::int(es.sp.weights.mu/5)]\n es.sigma *= np.exp(np.dot(es.sp.weights, slengths / es.N - 1))**(2 / (es.N + 1))\n if 11 < 3:\n es.more_to_write.append(10**((sum(self.ps**2) / es.N / 2 - 1 / 2 if es.opts['CSA_squared'] else _norm(self.ps) / es.const.chiN - 1)))\n es.more_to_write.append(10**(-3.5 + sum(self.ps**2) / es.N / 2 - _norm(self.ps) / es.const.chiN))\n # es.more_to_write.append(10**(-3 + sum(es.arz[es.fit.idx[0]]**2) / es.N))","def handle_gradient(self):\n self._optimizer.sync_grad()","def __init__(self, mean=0.0, sigma=1.0):\n super().__init__()\n self.mean = mean\n self.sigma = sigma\n self.hasInfiniteBound = True\n self.type = 'Normal'\n self.distType = 'Continuous'\n self.compatibleQuadrature.append('Hermite')\n self.compatibleQuadrature.append('CDF')\n #THESE get set in initializeDistribution, since it depends on truncation\n #self.preferredQuadrature = 'Hermite'\n #self.preferredPolynomials = 'Hermite'","def update(self, x):\n with torch.no_grad():\n x_channel_first = x.to(self.dtype).transpose(0, 1).reshape(x.size(1), -1)\n new_count = torch.full_like(self._count, x.size(0)).float()\n new_mean = x_channel_first.mean(-1)\n\n if self._distributed:\n distrib.all_reduce(new_count)\n\n new_mean = new_mean.float()\n distrib.all_reduce(new_mean)\n\n # msg = torch.cat([new_mean, new_count.unsqueeze(-1)])\n # distrib.all_reduce(msg)\n # new_mean = msg[0:-1]\n # new_count = msg[-1]\n\n new_mean /= distrib.get_world_size()\n\n # new_var = (x_channel_first - new_mean.view(x.size(1), -1)).pow(2).mean(-1)\n new_var = (\n x_channel_first - new_mean.view(x.size(1), -1).type_as(x)\n ).pow(2).mean(-1, keepdim=True).float()\n\n if self._distributed:\n distrib.all_reduce(new_var)\n new_var /= distrib.get_world_size()\n new_var = new_var.view(self._shape)\n new_mean = new_mean.view(self._shape).float()\n\n self._mean, self._var, self._count = welford_update(\n self._mean, self._var, self._count, new_mean, new_var, new_count,\n )","def update_total_fpsig_dict(self):\n for curr_CD in self.total_inputsr_dict.keys():\n self.total_fpsig_dict[curr_CD] = 0.0\n for c in self.source_connection_list:\n if(c.conn_type =='ShortRange'):\n self.total_fpsig_dict[c.connection_distribution] += (c.curr_firing_rate) * (c.weights**2) * c.nsyn\n\n # summation\n self.total_fp_sigv = 0.0\n for key,val in self.total_fpsig_dict.items():\n try:\n self.total_fp_sigv += val\n except:\n key.initialize()\n self.total_fp_sigv += val\n self.total_fp_sigv = self.total_fp_sigv * self.tau_m","def soft_update(self, other, tau):\n new_weights = {}\n\n own_weights = self.get_weight_copies()\n other_weights = other.get_weight_copies()\n\n for k in own_weights:\n #print(own_weights[k].shape, other_weights[k].shape)\n new_weights[k] = (1 - tau) * own_weights[k] + tau * other_weights[k]\n self.set_weights(new_weights)","def update(self):\n\n # get states, actions, rewards and total timesteps from memory\n states, actions, R, T = self.memory.get()\n n_ep = len(R)\n\n # compute value estimates for the states\n v = self.critic(states)\n\n # compute advantages (using GAE) and rewards to go\n A, rtg = utils.gae_rtg((R, v, T), self.gam, self.lam)\n\n # store the initial version of both the policy and the log probs of the\n # actions for later comparison with the future versions (needed for PPO)\n policy_old = copy.deepcopy(self.policy)\n log_probs_old = policy_old(states).log_prob(actions)\n\n # sample from a batch of experiences\n # (\"_\" subscript indicates \"sampled from\")\n for (v_, A_, rtg_, log_probs_old_), i in utils.sample_batch((v, A, rtg, log_probs_old), self.batch_size, self.policy_updates):\n log_probs_ = self.policy(states).log_prob(actions)[i]\n\n # estimate ratio between the new log probs and the old ones\n r_ = torch.exp(log_probs_ - log_probs_old_)\n\n l_1 = r_ * A_\n l_2 = torch.clamp(r_, 1-self.eps, 1+self.eps) * A_\n\n # TODO: implement entropy\n # TODO: merge policy and critic\n\n # surragate loss function for PPO\n l_clip = -torch.mean(torch.min(l_1, l_2))\n\n # update the policy\n self.policy_optimizer.zero_grad()\n l_clip.backward(retain_graph=True)\n self.policy_optimizer.step()\n\n # sample a batch of value estimates and the corresponding rewards to go\n # to update the value function.\n for (v_, rtg_), _ in utils.sample_batch((v, rtg), self.batch_size, self.v_updates):\n # compute the loss\n critic_loss = F.mse_loss(v_, rtg_)\n\n # update the critic\n self.critic_optimizer.zero_grad()\n critic_loss.backward(retain_graph=True)\n self.critic_optimizer.step()\n\n # clear the memory. PPO is an On-Policy method so we don't need these\n # memories anymore\n self.memory.clear()\n\n # return the loss of the value function for display\n return F.mse_loss(v, rtg)","def compute_updates(self, xs, gs, state=None):\n raise NotImplementedError()","def applyBoltzmannDist(self):\n normDist = []\n scaling_factor = math.sqrt(self.kb*self.temp/self.m)\n\n # Establish Normal Distribution\n for i in range(0, 3*self.numAtoms):\n normDist.append(random.gauss(0,1))\n \n # Apply scaling factor to distribution\n for number in range(0, 3*self.numAtoms):\n normDist[number] = normDist[number]*scaling_factor\n \n # Distribute velocities\n for atom in range(0, self.numAtoms):\n self.atoms[atom].vx = normDist[atom*3]\n self.atoms[atom].vy = normDist[atom*3+1]\n self.atoms[atom].vz = normDist[atom*3+2]","def update_points(self, acqfunc_values, indices, dscale):\n ind, val = self.checkvalues(indices, acqfunc_values)\n new_start_idx = np.where(np.array(acqfunc_values) == val)[0][0]\n acqfunc_values = np.array(acqfunc_values)[new_start_idx:]\n indices = np.vstack(indices)[new_start_idx:]\n acqfunc_values_ = copy.deepcopy(acqfunc_values)\n minval = acqfunc_values.min()\n new_max = acqfunc_values.max()\n new_max_id = np.argmax(acqfunc_values)\n max_val_all, max_id_all = [], []\n ck = indices[new_max_id]\n tree = spatial.cKDTree(indices)\n while new_max > minval - 1:\n max_val_all.append(new_max)\n max_id_all.append(new_max_id)\n nn_indices = tree.query_ball_point(ck, dscale)\n acqfunc_values[nn_indices] = minval - 1\n new_max = acqfunc_values.max()\n new_max_id = np.argmax(acqfunc_values)\n ck = indices[new_max_id]\n max_val_all = max_val_all[:self.batch_out_max]\n indices_ = indices[max_id_all].tolist()[:self.batch_out_max]\n if len(indices_) < self.batch_out_max:\n if self.verbose == 2:\n print(\"Adding {} random indices\".format(\n self.batch_out_max - len(indices_)))\n idx_random = np.random.randint(\n 0, len(acqfunc_values), self.batch_out_max - len(indices_))\n indices_.extend(indices[idx_random].tolist())\n max_val_all.extend(acqfunc_values_[idx_random].tolist())\n return max_val_all, indices_","def update2(self, es, **kwargs):\n self._update_ps(es) # caveat: if es.B or es.D are already updated and ps is not, this goes wrong!\n p = self.ps\n try: pc_for_ps = 'pc for ps' in es.opts['vv'] # just in case\n except: pc_for_ps = False # 'vv' has an incompatible format or does't exist\n if pc_for_ps:\n # was: es.D**-1 * np.dot(es.B.T, es.pc)\n if es.opts['verbose'] > 5 and es.countiter == 1:\n utils.print_message('pc for ps is active')\n p = es.sm.transform_inverse(es.pc)\n try: # to filter coordinates or a\n p = es.path_for_sigma_update(p) # subspace depending on the state\n except AttributeError:\n if 11 < 3 and len(es.opts['integer_variables']):\n m = (\"Missing ``path_for_sigma_update`` attribute in {}.\"\n \"\\n This is usually not a problem unless integer mutations are used.\"\n \"\".format(type(es)))\n _warnings.warn(m)\n N = len(p)\n if N == 0: # all variables are masked, do nothing\n return 1\n if es.opts['CSA_squared']:\n s = (sum(_square(p)) / N - 1) / 2\n # sum(self.ps**2) / es.N has mean 1 and std sqrt(2/N) and is skewed\n # divided by 2 to have the derivative d/dx (x**2 / N - 1) for x**2=N equal to 1\n else:\n s = _norm(p) / Mh.chiN(N) - 1\n s *= self.cs / self.damps\n s_clipped = Mh.minmax(s, -self.max_delta_log_sigma, self.max_delta_log_sigma)\n # \"error\" handling\n if s_clipped != s:\n utils.print_warning('sigma change np.exp(' + str(s) + ') = ' + str(np.exp(s)) +\n ' clipped to np.exp(+-' + str(self.max_delta_log_sigma) + ')',\n 'update',\n 'CMAAdaptSigmaCSA',\n es.countiter, es.opts['verbose'])\n self.delta *= np.exp(s_clipped)\n return np.exp(s_clipped)","def update_boundary(self):\n\n cell = self._fire_boundary.dequeue()\n neighbors = self.four_neighbors(cell[0], cell[1])\n #neighbors = self.eight_neighbors(cell[0], cell[1])\n for neighbor in neighbors:\n if self.is_empty(neighbor[0], neighbor[1]):\n self.set_full(neighbor[0], neighbor[1])\n self._fire_boundary.enqueue(neighbor)\n\n # Check class invariant after update\n assert self.boundary_invariant()","def perform_update(self, gradient):\n w = sys.modules[self.shared_mem_name].__dict__[\"w\"]\n w -= self.learning_rate * gradient","def _update(self, bandit): \n \n bandit_logs = self.logging[bandit]\n bandit = bandit.id\n estimate = bandit_logs['reward'] / bandit_logs['actions'] # if not assigned\n actions = bandit_logs['actions']\n self.mu[bandit] = (self.mu_pri[bandit]/self.var_pri[bandit] + actions*estimate/self.var0)/(actions/self.var0 + 1/self.var_pri[bandit])\n self.var[bandit] = 1/(actions/self.var0 + 1/self.var[bandit])","def __init__(self, quantity, dist_weights, gauss_params, upper_bound, lower_bound):\n self.dist_weights = dist_weights\n self.lower_bound = lower_bound\n self.upper_bound = upper_bound\n if len(self.dist_weights) != len(gauss_params):\n print(\n \"Number of distribution weights do not match number of distributions!\"\n )\n diff = len(gauss_params) - len(dist_weights)\n if diff < 0:\n print(\"Ignoring trailing distribution weights\")\n self.dist_weights = self.dist_weights[: len(dist_weights) + diff]\n else:\n print(\"Assuming default weights of 1\")\n self.dist_weights.extend([1] * diff)\n # normalize weights\n self.dist_weights = np.array(\n [float(i) / sum(self.dist_weights) for i in self.dist_weights]\n )\n # create samples\n self.samples = []\n self.gauss_params = gauss_params\n sample_size = quantity\n self.sample_min, self.sample_max = [float(\"inf\"), -float(\"inf\")]\n while True:\n # determine the gaussian to sample from for each sample\n mixture_idx = np.random.choice(\n len(self.dist_weights),\n size=sample_size,\n replace=True,\n p=self.dist_weights,\n )\n # create the samples from the respective gaussian\n temp = np.fromiter(\n (ss.norm.rvs(*(gauss_params[i])) for i in mixture_idx), dtype=np.float64\n )\n # remember mixed sampled extremas for plotting\n self.sample_min = min(self.sample_min, temp.min())\n self.sample_max = max(self.sample_max, temp.max())\n # add those samples that are within the bounds\n self.samples = np.concatenate(\n [\n self.samples,\n np.fromiter(\n [x for x in temp if x <= upper_bound and x >= lower_bound],\n dtype=np.float64,\n ),\n ]\n )\n sample_size = quantity - len(self.samples)\n if sample_size == 0:\n break","def update_feq(self):\n\n sim = self.sim\n\n self.sim.kernels.update_feq_fluid(\n sim.queue, sim.two_d_global_size, sim.two_d_local_size,\n sim.feq.data,\n sim.rho.data,\n sim.u_bary.data, sim.v_bary.data,\n sim.w, sim.cx, sim.cy, sim.cs,\n sim.nx, sim.ny,\n self.field_index, sim.num_populations,\n sim.num_jumpers).wait()","def _update_mean_and_sigma_inv_times_centered_y(self):\n\n if self._sigma_inv_times_centered_y is not None:\n update_condition = (\n len(self._sigma_inv_times_centered_y) != len(self.list_y)\n )\n else:\n update_condition = self._mean_y is None\n\n if update_condition:\n y, mean = self._solve_linear_system()\n self._sigma_inv_times_centered_y = y\n self._mean_y = mean","def update(self):\n with torch.no_grad():\n self.preprocess_rollout()\n \n # DEEP-RL TUTORIALS: КОСТЫЛЬ\n #self.advantages = self.returns[:-1] - self.values[:-1]\n #self.advantages = (self.advantages - self.advantages.mean()) / (self.advantages.std() + 1e-5)\n \n # going through rollout several (config.epochs) times:\n for epoch in range(self.config.epochs):\n # TODO: drop last = False? What if there is 1 sample?\n sampler = BatchSampler(SubsetRandomSampler(range(self.env.num_envs * self.config.rollout)), self.config.batch_size, drop_last=False)\n \n for indices in sampler:\n # retrieving new batch as part of rollout\n self.returns_b = self.returns.view(-1, *self.config.value_repr_shape)[indices]\n self.old_values_b = self.values.view(-1, *self.config.value_repr_shape)[indices]\n self.old_action_log_probs_b = self.action_log_probs.view(-1)[indices]\n #self.advantages_b = self.advantages.view(-1)[indices] # КОСТЫЛЬ\n \n # calculating current value, action_log_prob, entropy\n dist, self.values_b = self.policy(self.observations.view(-1, *self.config.observation_shape)[indices])\n self.values_b = self.values_b.squeeze() # IMPORTANT ([32] - [32, 1] problem)\n self.action_log_probs_b = dist.log_prob(self.actions.view(-1, *self.config.actions_shape)[indices])#.sum(dim=-1) \n self.entropy_b = dist.entropy()#.sum(dim=-1)\n \n # performing step\n self.gradient_ascent_step()","def __call__(self):\n\n if self.indices is []:\n return\n\n\n #-----------------------------------------\n # Here is where the important formula is applied\n #----------------------------------------\n if self.indices is None:\n height = self.stage_c - self.elev_c\n self.friction_c[:] = self.friction(height)\n else:\n ind = self.indices\n height = self.stage_c[ind] - self.elev_c[ind]\n self.friction_c[ind] = self.friction(height)","def updateWeights(self,weightUpdate):\n\t\n\t\tbranches = self.collectAllBranches()\n\n\t\tfor i in range(self.nBranches):\n\n\t\t\tbranches[i].weight -= weightUpdate[i]","def distribution(self, env):\n pass","def release_update(self, surfaces, release_state): \n # Set the integrator to the release state.\n self._s2 = (release_state['t'], release_state['q'], release_state['p'])\n\n # Remove the constraints from the system.\n remove_constraints(self, surfaces)\n #remove_list = []\n #for con in self._state1_impacts:\n # if con in self.system.constraints:\n # remove_list.append(con)\n #remove_constraints(self, remove_list) \n\n self._tau1 = TAU(self)\n\n # Step to the end of the current timestep.\n if self.t_end != self.t2:\n self.lambda0 = self.lambda1\n self.step(self.t_end, k2=self.kin_config(self.t_end))"],"string":"[\n \"def update(self, function_values, es, bounds=None):\\r\\n if bounds is None:\\r\\n bounds = self.bounds\\r\\n if bounds is None or (bounds[0] is None and bounds[1] is None): # no bounds ==> no penalty\\r\\n return self # len(function_values) * [0.0] # case without voilations\\r\\n\\r\\n N = es.N\\r\\n ### prepare\\r\\n # compute varis = sigma**2 * C_ii\\r\\n varis = es.sigma**2 * array(N * [es.C] if np.isscalar(es.C) else ( # scalar case\\r\\n es.C if np.isscalar(es.C[0]) else # diagonal matrix case\\r\\n [es.C[i][i] for i in xrange(N)])) # full matrix case\\r\\n\\r\\n # dmean = (es.mean - es.gp.into_bounds(es.mean)) / varis**0.5\\r\\n dmean = (es.mean - es.gp.geno(es.gp.into_bounds(es.gp.pheno(es.mean)))) / varis**0.5\\r\\n\\r\\n ### Store/update a history of delta fitness value\\r\\n fvals = sorted(function_values)\\r\\n l = 1 + len(fvals)\\r\\n val = fvals[3*l // 4] - fvals[l // 4] # exact interquartile range apart interpolation\\r\\n val = val / np.mean(varis) # new: val is normalized with sigma of the same iteration\\r\\n # insert val in history\\r\\n if np.isfinite(val) and val > 0:\\r\\n self.hist.insert(0, val)\\r\\n elif val == inf and len(self.hist) > 1:\\r\\n self.hist.insert(0, max(self.hist))\\r\\n else:\\r\\n pass # ignore 0 or nan values\\r\\n if len(self.hist) > 20 + (3*N) / es.popsize:\\r\\n self.hist.pop()\\r\\n\\r\\n ### prepare\\r\\n dfit = np.median(self.hist) # median interquartile range\\r\\n damp = min(1, es.sp.mueff/10./N)\\r\\n\\r\\n ### set/update weights\\r\\n # Throw initialization error\\r\\n if len(self.hist) == 0:\\r\\n raise _Error('wrongful initialization, no feasible solution sampled. ' +\\r\\n 'Reasons can be mistakenly set bounds (lower bound not smaller than upper bound) or a too large initial sigma0 or... ' +\\r\\n 'See description of argument func in help(cma.fmin) or an example handling infeasible solutions in help(cma.CMAEvolutionStrategy). ')\\r\\n # initialize weights\\r\\n if (dmean.any() and (not self.weights_initialized or es.countiter == 2)): # TODO\\r\\n self.gamma = array(N * [2*dfit])\\r\\n self.weights_initialized = True\\r\\n # update weights gamma\\r\\n if self.weights_initialized:\\r\\n edist = array(abs(dmean) - 3 * max(1, N**0.5/es.sp.mueff))\\r\\n if 1 < 3: # this is better, around a factor of two\\r\\n # increase single weights possibly with a faster rate than they can decrease\\r\\n # value unit of edst is std dev, 3==random walk of 9 steps\\r\\n self.gamma *= exp((edist>0) * np.tanh(edist/3) / 2.)**damp\\r\\n # decrease all weights up to the same level to avoid single extremely small weights\\r\\n # use a constant factor for pseudo-keeping invariance\\r\\n self.gamma[self.gamma > 5 * dfit] *= exp(-1./3)**damp\\r\\n # self.gamma[idx] *= exp(5*dfit/self.gamma[idx] - 1)**(damp/3)\\r\\n elif 1 < 3 and (edist>0).any(): # previous method\\r\\n # CAVE: min was max in TEC 2009\\r\\n self.gamma[edist>0] *= 1.1**min(1, es.sp.mueff/10./N)\\r\\n # max fails on cigtab(N=12,bounds=[0.1,None]):\\r\\n # self.gamma[edist>0] *= 1.1**max(1, es.sp.mueff/10./N) # this was a bug!?\\r\\n # self.gamma *= exp((edist>0) * np.tanh(edist))**min(1, es.sp.mueff/10./N)\\r\\n else: # alternative version, but not better\\r\\n solutions = es.pop # this has not been checked\\r\\n r = self.feasible_ratio(solutions) # has to be the averaged over N iterations\\r\\n self.gamma *= exp(np.max([N*[0], 0.3 - r], axis=0))**min(1, es.sp.mueff/10/N)\\r\\n es.more_to_write += list(self.gamma) if self.weights_initialized else N * [1.0]\\r\\n ### return penalty\\r\\n # es.more_to_write = self.gamma if not np.isscalar(self.gamma) else N*[1]\\r\\n return self # bound penalty values\\r\",\n \"def initializeDistribution(self):\\n if (self.lowerBoundUsed == False and self.upperBoundUsed == False):\\n self._distribution = distribution1D.BasicWeibullDistribution(self.k,self.lambdaVar,self.low)\\n self.lowerBound = self.low\\n self.upperBound = sys.float_info.max\\n else:\\n if self.lowerBoundUsed == False:\\n self.lowerBound = self.low\\n if self.upperBoundUsed == False:\\n self.upperBound = sys.float_info.max\\n self._distribution = distribution1D.BasicWeibullDistribution(self.k,self.lambdaVar,self.lowerBound,self.upperBound,self.low)\",\n \"def update_distribution(self):\\n for m in range(0, self.document_number, 1):\\n for k in range(0, self.topic_number, 1):\\n self.document_distribution_over_topic[m][k]+=((self.document_topic_count_matrix[m][k] + self.alpha[k])\\n / (self.sum_document_by_topic_count[m] + self.sum_alpha))\\n for k in range(0, self.topic_number, 1):\\n for v in range(0, self.term_number,1):\\n self.topic_distribution_over_term[k][v] += ((self.topic_term_count_matrix[k][v] + self.beta[v]) / \\\\\\n (self.sum_topic_by_term_count[k] + self.sum_beta))\\n # the number of times that the distributions are updated.\\n self.update_number += 1\",\n \"def update(self):\\n ## Initialize\\n self.domain.update()\\n self.var = self.domain.var.copy()\\n self.out = []\\n\\n ## Construct var and out, respecting DAG properties\\n for fun in self.functions:\\n self.var = list(set(self.var).union(set(fun.var).difference(set(self.out))))\\n\\n self.out = list(set(self.out).union(set(fun.out)))\\n\\n try:\\n self.var_rand = list(self.density.marginals.keys())\\n except AttributeError:\\n self.var_rand = []\\n self.var_det = list(set(self.var).difference(self.var_rand))\\n\\n ## TODO parameters\\n\\n ## Convenience constants\\n self.n_var = len(self.var)\\n self.n_var_rand = len(self.var_rand)\\n self.n_var_det = len(self.var_det)\\n self.n_out = len(self.out)\",\n \"def initializeDistribution(self):\\n if (self.lowerBoundUsed == False and self.upperBoundUsed == False):\\n self._distribution = distribution1D.BasicExponentialDistribution(self.lambdaVar,self.low)\\n self.lowerBound = self.low\\n self.upperBound = sys.float_info.max\\n else:\\n if self.lowerBoundUsed == False:\\n self.lowerBound = self.low\\n if self.upperBoundUsed == False:\\n self.upperBound = sys.float_info.max\\n self._distribution = distribution1D.BasicExponentialDistribution(self.lambdaVar,self.lowerBound,self.upperBound,self.low)\",\n \"def update_forces(self):\\n\\n pass\",\n \"def initializeDistribution(self):\\n self.minVal = min(math.exp(self.upperBound),math.exp(self.lowerBound))\\n self.maxVal = max(math.exp(self.upperBound),math.exp(self.lowerBound))\",\n \"def initializeDistribution(self):\\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\\n self._distribution = distribution1D.BasicLogNormalDistribution(self.mean,self.sigma,self.low)\\n self.lowerBound = 0.0\\n self.upperBound = sys.float_info.max\\n else:\\n if self.lowerBoundUsed == False:\\n self.lowerBound = self.low\\n if self.upperBoundUsed == False:\\n self.upperBound = sys.float_info.max\\n self._distribution = distribution1D.BasicLogNormalDistribution(self.mean,self.sigma,self.lowerBound,self.upperBound, self.low)\",\n \"def initializeDistribution(self):\\n if self.functionType == 'CDF':\\n self._distribution = distribution1D.BasicMultiDimensionalInverseWeight(str(self.dataFilename), self.p,True)\\n else:\\n self._distribution = distribution1D.BasicMultiDimensionalInverseWeight(str(self.dataFilename), self.p,False)\\n self.dimensionality = self._distribution.returnDimensionality()\\n self.lowerBound = [self.returnLowerBound(dim) for dim in range(self.dimensionality)]\\n self.upperBound = [self.returnUpperBound(dim) for dim in range(self.dimensionality)]\",\n \"def initializeDistribution(self):\\n self.convertToDistrDict['Laguerre'] = self.convertLaguerreToGamma\\n self.convertToQuadDict ['Laguerre'] = self.convertGammaToLaguerre\\n self.measureNormDict ['Laguerre'] = self.stdProbabilityNorm\\n if (not self.upperBoundUsed):\\n # and (not self.lowerBoundUsed):\\n self._distribution = distribution1D.BasicGammaDistribution(self.alpha,1.0/self.beta,self.low)\\n #self.lowerBoundUsed = 0.0\\n self.upperBound = sys.float_info.max\\n self.preferredQuadrature = 'Laguerre'\\n self.preferredPolynomials = 'Laguerre'\\n else:\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'Legendre'\\n if self.lowerBoundUsed == False:\\n a = 0.0\\n self.lowerBound = a\\n else:\\n a = self.lowerBound\\n if self.upperBoundUsed == False:\\n b = sys.float_info.max\\n self.upperBound = b\\n else:\\n b = self.upperBound\\n self._distribution = distribution1D.BasicGammaDistribution(self.alpha,1.0/self.beta,self.low,a,b)\",\n \"def initializeDistribution(self):\\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\\n self._distribution = distribution1D.BasicLogisticDistribution(self.location,self.scale)\\n else:\\n if self.lowerBoundUsed == False:\\n a = -sys.float_info.max\\n else:\\n a = self.lowerBound\\n if self.upperBoundUsed == False:\\n b = sys.float_info.max\\n else:\\n b = self.upperBound\\n self._distribution = distribution1D.BasicLogisticDistribution(self.location,self.scale,a,b)\",\n \"def initializeDistribution(self):\\n self.convertToDistrDict['Jacobi'] = self.convertJacobiToBeta\\n self.convertToQuadDict ['Jacobi'] = self.convertBetaToJacobi\\n self.measureNormDict ['Jacobi'] = self.stdProbabilityNorm\\n #this \\\"if\\\" section can only be called if distribution not generated using readMoreXML\\n if (not self.upperBoundUsed) and (not self.lowerBoundUsed):\\n self._distribution = distribution1D.BasicBetaDistribution(self.alpha,self.beta,self.high-self.low,self.low)\\n else:\\n if self.lowerBoundUsed == False:\\n a = 0.0\\n else:\\n a = self.lowerBound\\n if self.upperBoundUsed == False:\\n b = sys.float_info.max\\n else:\\n b = self.upperBound\\n self._distribution = distribution1D.BasicBetaDistribution(self.alpha,self.beta,self.high-self.low,a,b,self.low)\\n self.preferredPolynomials = 'Jacobi'\\n self.compatibleQuadrature.append('Jacobi')\\n self.compatibleQuadrature.append('ClenshawCurtis')\",\n \"def updateBeta(self):\\n\\n priorBeta = np.copy(self.beta) # 返り値で更新幅を与えるので初期値を保持しておく\\n W = self.__genW() # diag Matrix\\n # update beta : Fisher Scoring Update\\n result = np.matmul(np.matmul(self.X.T, W), self.X)\\n result = np.matmul(np.linalg.inv(result), self.X.T)\\n result = np.matmul(result, W)\\n # claimFreq=0の人は, firstIterationでmu=0の0割が必ず発生する. 適切な対処法は+epsilonで良い?\\n z = (self.Y - self.mu)/(self.mu + DoubleGLM.EPSILON) + np.log(self.mu + DoubleGLM.EPSILON)\\n self.beta = np.matmul(result, z)\\n\\n # update current mu\\n self.mu = np.exp(np.matmul(self.X, self.beta))\\n # update current deviance\\n d1 = self.Y * (self.Y**(1-self.p) - self.mu**(1-self.p)) / (1-self.p)\\n d2 = (self.Y**(2-self.p) - self.mu**(2-self.p)) / (2-self.p)\\n self.d = 2*self.w * (d1 - d2)\\n\\n return np.abs(priorBeta - self.beta)\",\n \"def initializeDistribution(self):\\n self.convertToDistrDict['Legendre'] = self.convertLegendreToUniform\\n self.convertToQuadDict ['Legendre'] = self.convertUniformToLegendre\\n self.measureNormDict ['Legendre'] = self.stdProbabilityNorm\\n self.convertToDistrDict['ClenshawCurtis'] = self.convertLegendreToUniform\\n self.convertToQuadDict ['ClenshawCurtis'] = self.convertUniformToLegendre\\n self.measureNormDict ['ClenshawCurtis'] = self.stdProbabilityNorm\\n self._distribution = distribution1D.BasicUniformDistribution(self.lowerBound,self.lowerBound+self.range)\",\n \"def bayesian_update(self):\\n for p in self.parameters:\\n p.bayesian_update()\",\n \"def update(self, es, function_values, **kwargs):\\n # On the linear function, the two mirrored samples lead\\n # to a sharp increase of the condition of the covariance matrix,\\n # unless we have negative weights (which we have now by default).\\n # Otherwise they should not be used to update the covariance\\n # matrix, if the step-size inreases quickly.\\n if self.initialized is not True: # try again\\n self.initialize(es.N, es.opts)\\n if self.initialized is not True:\\n utils.print_warning(\\\"dimension not known, damping set to 4\\\",\\n 'update', 'CMAAdaptSigmaTPA')\\n self.initialized = True\\n if 1 < 3:\\n f_vals = np.asarray(function_values)\\n z = np.sum(f_vals < f_vals[1]) - np.sum(f_vals < f_vals[0])\\n z /= len(f_vals) - 1 # z in [-1, 1]\\n elif 1 < 3:\\n # use the ranking difference of the mirrors for adaptation\\n # damp = 5 should be fine\\n z = np.nonzero(es.fit.idx == 1)[0][0] - np.nonzero(es.fit.idx == 0)[0][0]\\n z /= es.popsize - 1 # z in [-1, 1]\\n self.s = (1 - self.sp.c) * self.s + self.sp.c * np.sign(z) * np.abs(z)**self.sp.z_exponent\\n if self.s > 0:\\n es.sigma *= np.exp(self.s / self.sp.dampup)\\n else:\\n es.sigma *= np.exp(self.s / self.sp.dampdown)\\n #es.more_to_write.append(10**z)\",\n \"def update(self, X, Y, basisfunc=None):\\n\\n # Initialise algorithm on first call to update. This allows the\\n # algorithm to configure itself to the size of the first input/output\\n # data if no hyper-parameters have been specified.\\n if not self.__initialised:\\n init_basis = self.__basisfunc if basisfunc is None else basisfunc\\n x = init_basis(X)\\n m = x.shape[1] if np.ndim(x) > 1 else X.size\\n n = Y.shape[1] if np.ndim(Y) > 1 else Y.size\\n self.__initialise_algorithm(m, n)\\n self.__initialised = True\\n\\n # Get size of data.\\n k = X.shape[0] if np.ndim(X) > 1 else X.size\\n m, n = self.__m, self.__n\\n\\n # Allocate variables for the dynamic programming pass.\\n loglik = -np.inf\\n logmax = -np.inf\\n logsum = -np.inf\\n ind = np.nan\\n\\n # Update hypotheses by updating each matrix variate, normal inverse\\n # gamma distribution over the linear models.\\n for hypothesis in self.__hypotheses:\\n\\n # Update the sufficient statistics.\\n hypothesis['distribution'].update(hypothesis['basisfunc'](X), Y)\\n\\n # Compute the log-normalization constant after the update\\n # (posterior parameter distribution).\\n # (Equation 8)\\n n_o = hypothesis['log_constant']\\n n_k = hypothesis['log_constant'] = hypothesis['distribution'].log_constant()\\n\\n # Evaluate the log-density of the predictive distribution.\\n # (Equation 16)\\n log_density = n_k - n_o - k * (0.5 * m * n) * np.log(2.0 * np.pi)\\n\\n # Increment the counter.\\n hypothesis['count'] += 1\\n\\n # Accumulate the log-likelihood of the data.\\n # (Equation 17)\\n hazard = self.__ratefun(hypothesis['count'])\\n aux = np.log(hazard) + log_density + hypothesis['log_probability']\\n loglik = self.__soft_max(loglik, aux)\\n\\n # Keep track of the highest, log-likelihood.\\n if aux > logmax:\\n logmax, ind = aux, hypothesis['count']\\n\\n # Update and accumulate the log-probabilities.\\n hypothesis['log_probability'] += np.log1p(-hazard) + log_density\\n logsum = self.__soft_max(logsum, hypothesis['log_probability'])\\n\\n # In the max-product algorithm, keep track of the most likely\\n # hypotheses.\\n if self.__alg__ == 'maxprod':\\n loglik = logmax\\n self.__counts.append(ind)\\n\\n # Add a new hypothesis, which states that the next segment is about to\\n # begin.\\n self.__add_new_hypothesis(loglik, basisfunc)\\n\\n # Normalize the hypotheses so that their probabilities sum to one.\\n logsum = self.__soft_max(logsum, loglik)\\n for hypothesis in self.__hypotheses:\\n hypothesis['log_probability'] -= logsum\\n\\n # Automatically trim hypothesis on each update if requested.\\n if self.__maximum_hypotheses is not None:\\n self.trim_hypotheses(minprob=self.__minimum_probability,\\n maxhypot=self.__maximum_hypotheses)\\n\\n # In the sum-product algorithm, keep track of the probabilities.\\n if self.__alg__ == 'sumprod':\\n iteration = list()\\n for hypothesis in self.__hypotheses:\\n iteration.append((hypothesis['count'],\\n hypothesis['log_probability']))\\n\\n self.__probabilities.append(iteration)\",\n \"def __init__(self):\\n super().__init__()\\n self.upperBoundUsed = False # True if the distribution is right truncated\\n self.lowerBoundUsed = False # True if the distribution is left truncated\\n self.hasInfiniteBound = False # True if the untruncated distribution has bounds of +- system max\\n self.upperBound = None # Right bound\\n self.lowerBound = None # Left bound\\n self.__adjustmentType = '' # this describe how the re-normalization to preserve the probability should be done for truncated distributions\\n self.dimensionality = None # Dimensionality of the distribution (1D or ND)\\n self.distType = None # Distribution type (continuous or discrete)\\n self.memory = False # This variable flags if the distribution has history dependence in the sampling process (True) or not (False)\\n self.printTag = 'DISTRIBUTIONS'\\n self.preferredPolynomials = None # best polynomial for probability-weighted norm of error\\n self.preferredQuadrature = None # best quadrature for probability-weighted norm of error\\n self.compatibleQuadrature = [] #list of compatible quadratures\\n self.convertToDistrDict = {} #dict of methods keyed on quadrature types to convert points from quadrature measure and domain to distribution measure and domain\\n self.convertToQuadDict = {} #dict of methods keyed on quadrature types to convert points from distribution measure and domain to quadrature measure and domain\\n self.measureNormDict = {} #dict of methods keyed on quadrature types to provide scalar adjustment for measure transformation (from quad to distr)\\n self.convertToDistrDict['CDFLegendre'] = self.CDFconvertToDistr\\n self.convertToQuadDict ['CDFLegendre'] = self.CDFconvertToQuad\\n self.measureNormDict ['CDFLegendre'] = self.CDFMeasureNorm\\n self.convertToDistrDict['CDFClenshawCurtis'] = self.CDFconvertToDistr\\n self.convertToQuadDict ['CDFClenshawCurtis'] = self.CDFconvertToQuad\\n self.measureNormDict ['CDFClenshawCurtis'] = self.CDFMeasureNorm\",\n \"def initializeDistribution(self):\\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\\n self._distribution = distribution1D.BasicGeometricDistribution(self.p)\\n else: self.raiseAnError(IOError,'Truncated Geometric not yet implemented')\",\n \"def initializeDistribution(self):\\n\\n f = open(self.dataFilename, 'r')\\n reader = csv.reader(f)\\n headers = next(reader)\\n indexFunctionID = headers.index(self.functionID)\\n indexVariableID = headers.index(self.variableID)\\n f.close()\\n rawData = np.genfromtxt(self.dataFilename, delimiter=\\\",\\\" , skip_header=1, usecols=(indexVariableID,indexFunctionID))\\n\\n self.data = rawData[rawData[:,0].argsort()]\\n self.lowerBound = self.data[0,0]\\n self.upperBound = self.data[-1,0]\\n\\n if self.functionType == 'cdf':\\n self.cdfFunc = UnivariateSpline(self.data[:,0], self.data[:,1], k=self.k, s=self.s)\\n self.pdfFunc = self.cdfFunc.derivative()\\n self.invCDF = UnivariateSpline(self.data[:,1], self.data[:,0], k=self.k, s=self.s)\\n else:\\n self.pdfFunc = UnivariateSpline(self.data[:,0], self.data[:,1], k=self.k, s=self.s)\\n cdfValues = np.zeros(self.data[:,0].size)\\n for i in range(self.data[:,0].size):\\n cdfValues[i] = self.pdfFunc.integral(self.data[0][0],self.data[i,0])\\n self.invCDF = UnivariateSpline(cdfValues, self.data[:,0] , k=self.k, s=self.s)\\n\\n # Note that self.invCDF is creating a new spline where I switch its term.\\n # Instead of doing spline(x,f(x)) I am creating its inverse spline(f(x),x)\\n # This can be done if f(x) is monothonic increasing with x (which is true for cdf)\",\n \"def update_forces(self):\\r\\n # update all the functions\\r\\n self.compute_gravity()\\r\\n self.compute_tides()\\r\\n self.compute_centrifugal()\\r\\n self.compute_coriolis()\\r\\n\\r\\n # add together the forces into the summation function\\r\\n self.forcing.assign(self.ftides+self.gravity +\\r\\n self.centrifugal+self.coriolis)\",\n \"def update(self):\\n self._g, self._B = self._constraint_assembler.preallocate_g_and_B(self._no_of_dofs_unconstrained,\\n self._dofidxs(),\\n self._no_of_constraints_by_object())\",\n \"def initializeDistribution(self):\\n if self.lowerBoundUsed == False:\\n self.lowerBound = -sys.float_info.max\\n if self.upperBoundUsed == False:\\n self.upperBound = sys.float_info.max\\n self._distribution = distribution1D.BasicLaplaceDistribution(self.location,self.scale,self.lowerBound,self.upperBound)\",\n \"def update(self, space: Space, function: Function) -> None:\\n\\n self._local_seeding(space, function)\\n candidate = self._population_limiting(space)\\n self._global_seeding(space, function, candidate)\\n\\n space.agents, self.age = map(\\n list, zip(*sorted(zip(space.agents, self.age), key=lambda x: x[0].fit))\\n )\\n\\n self.age[0] = 0\",\n \"def _update_ps(self, es):\\n if not self.is_initialized_base:\\n self.initialize_base(es)\\n if self._ps_updated_iteration == es.countiter:\\n return\\n try:\\n if es.countiter <= es.sm.itereigenupdated:\\n # es.B and es.D must/should be those from the last iteration\\n utils.print_warning('distribution transformation (B and D) have been updated before ps could be computed',\\n '_update_ps', 'CMAAdaptSigmaBase', verbose=es.opts['verbose'])\\n except AttributeError:\\n pass\\n z = es.sm.transform_inverse((es.mean - es.mean_old) / es.sigma_vec.scaling)\\n # assert Mh.vequals_approximately(z, np.dot(es.B, (1. / es.D) *\\n # np.dot(es.B.T, (es.mean - es.mean_old) / es.sigma_vec.scaling)))\\n z *= es.sp.weights.mueff**0.5 / es.sigma / es.sp.cmean\\n self.ps = (1 - self.cs) * self.ps + (self.cs * (2 - self.cs))**0.5 * z\\n self._ps_updated_iteration = es.countiter\",\n \"def update(self, applyTo='global', conditions='True', param=\\\"None\\\"):\\n super(NeumannBoundary, self).update(applyTo, conditions, \\\"None\\\")\",\n \"def initializeDistribution(self):\\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\\n self._distribution = distribution1D.BasicPoissonDistribution(self.mu)\\n self.lowerBound = 0.0\\n self.upperBound = sys.float_info.max\\n else:\\n self.raiseAnError(IOError,'Truncated poisson not yet implemented')\",\n \"def updateDistribution(self, PD, bestSh):\\n #* Here bestSh is a dictionary as saved in self.Data\\n del self.Data[bestSh['Pat'].prev_order]\\n out = PD.lprevUpdate.pop(bestSh['Pat'].prev_order, None)\\n if not out:\\n print('Something is fishy')\\n else:\\n la = PD.updateDistribution( bestSh['SPat'].G, idx=bestSh['SPat'].cur_order, val_return='save', case=2 )\\n bestSh['SPat'].setLambda(la)\\n return\",\n \"def updateRanges(self):\\n # work directly on the histograms, no copy\\n for i in range(len(self)):\\n self[i].updateRange()\",\n \"def variational_update(self):\\n with self.elbo_check('update_p_allele_swap'):\\n self.model.update_p_allele_swap()\\n\\n with self.elbo_check('p_cn'):\\n self.model.update_p_cn()\\n\\n with self.elbo_check('p_breakpoint'):\\n self.model.update_p_breakpoint()\\n\\n with self.elbo_check('p_outlier_total'):\\n self.model.update_p_outlier_total()\\n\\n with self.elbo_check('p_outlier_allele'):\\n self.model.update_p_outlier_allele()\",\n \"def prob_update(self):\\n pass\",\n \"def initializeDistribution(self):\\n self.checkDistParams()\\n\\n self.lowerBound = min(self.mapping.keys())\\n self.upperBound = max(self.mapping.keys())\",\n \"def FB(self):\\n # The maximum update amount for these element\\n StepLength_DELTA = self.dt * (self.StepLength_LIMITS[1] -\\n self.StepLength_LIMITS[0]) / (6.0)\\n StepVelocity_DELTA = self.dt * (self.StepVelocity_LIMITS[1] -\\n self.StepVelocity_LIMITS[0]) / (2.0)\\n\\n # Add either positive or negative or zero delta for each\\n # NOTE: 'High' is open bracket ) so the max is 1\\n if self.StepLength < -self.StepLength_LIMITS[0] / 2.0:\\n StepLength_DIRECTION = np.random.randint(-1, 3, 1)[0]\\n elif self.StepLength > self.StepLength_LIMITS[1] / 2.0:\\n StepLength_DIRECTION = np.random.randint(-2, 2, 1)[0]\\n else:\\n StepLength_DIRECTION = np.random.randint(-1, 2, 1)[0]\\n StepVelocity_DIRECTION = np.random.randint(-1, 2, 1)[0]\\n\\n # Now, modify modifiable params AND CLIP\\n self.StepLength += StepLength_DIRECTION * StepLength_DELTA\\n self.StepLength = np.clip(self.StepLength, self.StepLength_LIMITS[0],\\n self.StepLength_LIMITS[1])\\n self.StepVelocity += StepVelocity_DIRECTION * StepVelocity_DELTA\\n self.StepVelocity = np.clip(self.StepVelocity,\\n self.StepVelocity_LIMITS[0],\\n self.StepVelocity_LIMITS[1])\",\n \"def _update_parameter(self, dWxh, dbh, dWhy, dby):\\n # Add code to update all the weights and biases here\",\n \"def update(self, es, **kwargs):\\n es.sigma = self.coefficient * es.sp.weights.mueff * _norm(es.mean) / es.N / es.sp.cmean\",\n \"def _modify_updates(self, updates):\\n\\n if self.max_kernel_norm is not None:\\n W, = self.transformer.get_params()\\n if W in updates:\\n updated_W = updates[W]\\n row_norms = T.sqrt(T.sum(T.sqr(updated_W), axis=(0, 1, 2)))\\n desired_norms = T.clip(row_norms, 0, self.max_kernel_norm)\\n scales = desired_norms / (1e-7 + row_norms)\\n updates[W] = (updated_W * scales.dimshuffle('x', 'x', 'x', 0))\",\n \"def _update_distribution(self, trajectories):\\n costs = trajectories[\\\"costs\\\"].copy()\\n actions = trajectories[\\\"actions\\\"].copy()\\n Q = cost_to_go(costs, self.gamma_seq)\\n best_id = np.argmin(Q, axis = 0)[0]\\n self.mean_action = (1.0 - self.step_size) * self.mean_action +\\\\\\n self.step_size * actions[best_id]\",\n \"def update_r(self):\\n self.gamma_r = self.gamma_s - self.gamma_q\\n self.Sigma_r = self.Sigma_s - self.Sigma_q\",\n \"def _update_(self):\\n self._update_distance_()\\n self._check_literature_name_()\",\n \"def initializeDistribution(self):\\n self.raiseAMessage('initialize distribution')\\n mu = distribution1D.vectord_cxx(len(self.mu))\\n for i in range(len(self.mu)):\\n mu[i] = self.mu[i]\\n covariance = distribution1D.vectord_cxx(len(self.covariance))\\n for i in range(len(self.covariance)):\\n covariance[i] = self.covariance[i]\\n if self.method == 'spline':\\n if self.covarianceType != 'abs':\\n self.raiseAnError(IOError,'covariance with type ' + self.covariance + ' is not implemented for ' + self.method + ' method')\\n self._distribution = distribution1D.BasicMultivariateNormal(covariance, mu)\\n elif self.method == 'pca':\\n self._distribution = distribution1D.BasicMultivariateNormal(covariance, mu, str(self.covarianceType), self.rank)\\n if self.transformation:\\n self.lowerBound = [-sys.float_info.max]*self.rank\\n self.upperBound = [sys.float_info.max]*self.rank\\n else:\\n self.lowerBound = [self.returnLowerBound(dim) for dim in range(self.dimension)]\\n self.upperBound = [self.returnUpperBound(dim) for dim in range(self.dimension)]\",\n \"def update(self, values, weights):\\n super().update(values)\",\n \"def update(self, values, weights):\\n super().update(values)\",\n \"def update(self, values, weights):\\n super().update(values)\",\n \"def update(self, values, weights):\\n super().update(values)\",\n \"def update(self):\\n # Update the weight matrix: \\n self.W -= self.lr * self.grad_W \\n \\n # Update the bias matrices:\\n self.b -= self.lr * np.array(self.grad_b) \\n self.c -= self.lr * np.array(self.grad_c)\",\n \"def update_policy(self):\\n self.optimizer.step()\\n self.optimizer.zero_grad()\",\n \"def update(self):\\n for p in self.persons:\\n p.update(self.max_step)\\n if p.state == State.INFECTED:\\n for other in self.persons:\\n if np.linalg.norm(p.position - other.position) < self.infection_radius and id(p) != id(other):\\n if other.state == State.HEALTHY:\\n other.state = random.choices(\\n list(State), weights=[0.0, 1.0, 0, 0])[0]\\n elif other.state == State.RECOVERED:\\n other.state = random.choices(\\n list(State), weights=[0, 0.1, 0.8, 0])[0]\",\n \"def get_distribution(self):\\n\\n # If the distributions have been updated before.\\n if self.update_number > 0:\\n for m in range(0, self.document_number, 1):\\n for k in range(0, self.topic_number,1):\\n probability = self.document_distribution_over_topic[m][k] / self.update_number\\n self.document_distribution_over_topic[m][k] = probability\\n for k in range(0, self.topic_number,1):\\n for v in range(0, self.term_number,1):\\n probability = self.topic_distribution_over_term[k][v] / self.update_number\\n self.topic_distribution_over_term[k][v] = probability\\n # The distributions have not been updated once.\\n else:\\n for m in range(0, self.document_number, 1):\\n for k in range(0, self.topic_number, 1):\\n self.document_distribution_over_topic[m][k] = (\\n (self.document_topic_count_matrix[m][k] + self.alpha[k]) / (\\n self.sum_document_by_topic_count[m] + self.sum_alpha))\\n for k in range(0, self.topic_number, 1):\\n for v in range(0, self.term_number, 1):\\n self.topic_distribution_over_term[k][v] = (\\n (self.topic_term_count_matrix[k][v] + self.beta[v]) / (\\n self.sum_topic_by_term_count[k] + self.sum_beta))\",\n \"def update_focal_axes(self):\\n self.update_sigma()\\n self.updateGL()\",\n \"def update_parameters(self):\\n # We update gamma, gamma0, lambda and nu in turn (Bottolo et al, 2011)\\n self.update_gamma()\\n self.update_gamma0()\\n self.update_lambda()\\n self.update_nu()\\n if self.sample_xi:\\n self.update_xi()\",\n \"def _update_parameters(self, curr_state, reward, next_state):\\n phi = self._features.vector(curr_state)\\n phi_dash = self._features.vector(next_state)\\n\\n self._A += np.outer(phi, (phi - self._gamma * phi_dash))\\n self._b += reward * phi\",\n \"def _distributed_apply(self, distribution, grads_hessian_and_vars, name, apply_state):\\n\\n def apply_grad_to_update_var(var, grad, hess):\\n \\\"\\\"\\\"Apply gradient to variable.\\\"\\\"\\\"\\n if isinstance(var, ops.Tensor):\\n raise NotImplementedError(\\\"Trying to update a Tensor \\\", var)\\n\\n apply_kwargs = {}\\n\\n if \\\"apply_state\\\" in self._dense_apply_args:\\n apply_kwargs[\\\"apply_state\\\"] = apply_state\\n update_op = self._resource_apply_dense(grad, hess, var, **apply_kwargs)\\n\\n if var.constraint is not None:\\n with ops.control_dependencies([update_op]):\\n return var.assign(var.constraint(var))\\n else:\\n return update_op\\n\\n eagerly_outside_functions = ops.executing_eagerly_outside_functions()\\n update_ops = []\\n with ops.name_scope(name or self._name, skip_on_eager=True):\\n for grad, hess, var in grads_hessian_and_vars:\\n\\n def _assume_mirrored(grad, hess):\\n if isinstance(grad, ds_values.PerReplica):\\n return ds_values.Mirrored(grad.values), ds_values.Mirrored(hess.values)\\n return grad, hess\\n\\n grad, hess = nest.map_structure(_assume_mirrored, grad, hess)\\n # Colocate the update with variables to avoid unnecessary communication\\n # delays. See b/136304694.\\n with distribution.extended.colocate_vars_with(var):\\n with ops.name_scope(\\\"update\\\" if eagerly_outside_functions else\\n \\\"update_\\\" + var.op.name, skip_on_eager=True):\\n update_ops.extend(distribution.extended.update(\\n var, apply_grad_to_update_var, args=(grad, hess), group=False))\\n\\n any_symbolic = any(isinstance(i, ops.Operation) or\\n tf_utils.is_symbolic_tensor(i) for i in update_ops)\\n if not context.executing_eagerly() or any_symbolic:\\n # If the current context is graph mode or any of the update ops are\\n # symbolic then the step update should be carried out under a graph\\n # context. (eager updates execute immediately)\\n with ops._get_graph_from_inputs(update_ops).as_default(): # pylint: disable=protected-access\\n with ops.control_dependencies(update_ops):\\n return self._iterations.assign_add(1, read_value=False)\\n\\n return self._iterations.assign_add(1)\",\n \"def update_posterior_probs(vars_):\\n vars_.weighted_sums += np.power(vars_.dprime_map[vars_.focus],2) * vars_.visual_field\\n vars_.post_probs = np.exp(vars_.weighted_sums) * vars_.prior_prob\\n vars_.post_probs /= np.sum(vars_.post_probs)\",\n \"def update(self, dt):\\n # get normal random iscipyut\\n u = self.prng.normal(size=(1, self._x.shape[1]))\\n # calculate state time derivative with state space equation\\n dx_dt = self._A.dot(self._x) + self._B * u\\n # apply update with Euler integration\\n self._x += dx_dt * dt\",\n \"def initializeDistribution(self):\\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\\n self._distribution = distribution1D.BasicBinomialDistribution(self.n,self.p)\\n else:\\n self.raiseAnError(IOError,'Truncated Binomial not yet implemented')\",\n \"def initializeDistribution(self):\\n self.raiseAMessage('initialize Distribution')\\n if self.functionType == 'CDF':\\n self._distribution = distribution1D.BasicMultiDimensionalCartesianSpline(str(self.dataFilename),True)\\n else:\\n self._distribution = distribution1D.BasicMultiDimensionalCartesianSpline(str(self.dataFilename),False)\\n self.dimensionality = self._distribution.returnDimensionality()\\n self.lowerBound = [self.returnLowerBound(dim) for dim in range(self.dimensionality)]\\n self.upperBound = [self.returnUpperBound(dim) for dim in range(self.dimensionality)]\",\n \"def Update(self):\\n if self.NAtt > 0:\\n self.D *= (self.NAcc / self.NAtt + 0.1) / (self.TargetAcc + 0.1)\\n self.D = min(self.MaxD, max(self.MinD, self.D))\",\n \"def update_throttled(self):\\n self.ros_if.update()\",\n \"def updateFitness(self):\\r\\n for candidate in self.candidates:\\r\\n candidate.updateFitness()\\r\\n return\",\n \"def initializeDistribution(self):\\n self.convertToDistrDict['Hermite'] = self.convertHermiteToNormal\\n self.convertToQuadDict ['Hermite'] = self.convertNormalToHermite\\n self.measureNormDict ['Hermite'] = self.stdProbabilityNorm\\n if (not self.upperBoundUsed) and (not self.lowerBoundUsed):\\n self._distribution = distribution1D.BasicNormalDistribution(self.mean,\\n self.sigma)\\n self.lowerBound = -sys.float_info.max\\n self.upperBound = sys.float_info.max\\n self.preferredQuadrature = 'Hermite'\\n self.preferredPolynomials = 'Hermite'\\n else:\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'Legendre'\\n if self.lowerBoundUsed == False:\\n a = -sys.float_info.max\\n self.lowerBound = a\\n else:\\n a = self.lowerBound\\n if self.upperBoundUsed == False:\\n b = sys.float_info.max\\n self.upperBound = b\\n else:\\n b = self.upperBound\\n self._distribution = distribution1D.BasicNormalDistribution(self.mean,\\n self.sigma,\\n a,b)\",\n \"def initializeDistribution(self):\\n if self.lowerBoundUsed == False and self.upperBoundUsed == False:\\n self._distribution = distribution1D.BasicBernoulliDistribution(self.p)\\n else:\\n self.raiseAnError(IOError,'Truncated Bernoulli not yet implemented')\",\n \"def update_target(self):\\n with torch.no_grad():\\n for target_q_param, q_param in zip(self.target_q_funcs.parameters(), self.q_funcs.parameters()):\\n target_q_param.data.copy_(self.tau * q_param.data + (1.0 - self.tau) * target_q_param.data)\\n for target_pi_param, pi_param in zip(self.target_policy.parameters(), self.policy.parameters()):\\n target_pi_param.data.copy_(self.tau * pi_param.data + (1.0 - self.tau) * target_pi_param.data)\",\n \"def _modify_updates(self, updates):\\n wxf = self.wxf\\n wyf = self.wyf\\n wxf_updated = updates[wxf]\\n wyf_updated = updates[wyf]\\n nwxf = (wxf_updated.std(0) + SMALL)[numpy.newaxis, :]\\n nwyf = (wyf_updated.std(0) + SMALL)[numpy.newaxis, :]\\n meannxf = nwxf.mean()\\n meannyf = nwyf.mean()\\n # Center filters\\n centered_wxf = wxf_updated - wxf_updated.mean(0)\\n centered_wyf = wyf_updated - wyf_updated.mean(0)\\n # Fix standard deviation\\n wxf_updated = centered_wxf * (meannxf / nwxf)\\n wyf_updated = centered_wyf * (meannyf / nwyf)\\n updates[wxf] = wxf_updated\\n updates[wyf] = wyf_updated\",\n \"def apply_fhd(self, gfhd):\\n for bl in self.data.keys():\\n i,j = bl\\n p1,p2 = self.pol\\n G = gfhd[p1][i]*gfhd[p2][j].conj()\\n ind = np.where(G != 0)[0]\\n self.data[bl][self.pol][:,ind] /= G[ind]\",\n \"def initializeDistribution(self):\\n if self.nPoints is None:\\n self.xArray = np.arange(self.lowerBound,self.upperBound+1)\\n else:\\n self.xArray = np.linspace(self.lowerBound,self.upperBound,self.nPoints)\\n\\n # Here the actual calculation of discrete distribution parameters is performed\\n self.pdfArray = 1.0/self.xArray.size * np.ones(self.xArray.size)\\n paramsDict={}\\n paramsDict['outcome'] = self.xArray\\n paramsDict['state'] = self.pdfArray\\n\\n self.categoricalDist = Categorical()\\n self.categoricalDist.initializeFromDict(paramsDict)\\n initialPerm = randomUtils.randomPermutation(self.xArray.tolist(),self)\\n self.pot = np.asarray(initialPerm)\",\n \"def update_focal_axes(self):\\n #self.update_sigma()\\n self.updateGL()\",\n \"def update_distr_and_return_proba(self, gp_conn=None): \\n\\n results = self.results_from_db(gp_conn)\\n self.arms_probability = dict.fromkeys(self.active_arms)\\n\\n for i in self.active_arms:\\n try:\\n self.arms_dict_params[i]['success'].append(results[i]['success'])\\n self.arms_dict_params[i]['trials'].append(results[i]['trials'])\\n self.arms_dict_params[i]['current_alpha'] += self.arms_dict_params[i]['success'][-1]\\n self.arms_dict_params[i]['current_beta'] += self.arms_dict_params[i]['trials'][-1] - \\\\\\n self.arms_dict_params[i]['success'][-1]\\n except:\\n # вот тут надо рэйзить ошибку\\n self.arms_dict_params[i]['success'].append(0)\\n self.arms_dict_params[i]['trials'].append(0)\\n\\n self.arms_probability[i] = random.betavariate(self.arms_dict_params[i]['current_alpha'],\\n self.arms_dict_params[i]['current_beta'])\\n self.arms_dict_params[i]['probability'].append(self.arms_probability[i])\\n\\n return self.arms_dict_params, self.arms_probability\",\n \"def update(\\n self, space: Space, function: Function, iteration: int, n_iterations: int\\n ) -> None:\\n\\n mean_position = np.mean([agent.position for agent in space.agents], axis=0)\\n\\n # Calculates the Sigma Reduction Factor (eq. 5)\\n SRF = (-np.log(1 - (1 / np.sqrt(iteration + 2)))) ** 2\\n\\n # Calculates the Beta Expansion Factor\\n BEF = self.beta + (2 - self.beta) * ((iteration + 1) / n_iterations)\\n\\n for agent in space.agents:\\n a = copy.deepcopy(agent)\\n\\n for j in range(agent.n_variables):\\n # Calculates the random walk (eq. 2 and 3)\\n random_step = r.generate_gaussian_random_number(mean_position[j], SRF)\\n\\n # Calculates the Lévy flight (eq. 6 to 18)\\n levy_step = d.generate_levy_distribution(BEF)\\n\\n a.position[j] += (\\n random_step\\n * levy_step\\n * (agent.position[j] - space.best_agent.position[j])\\n )\\n a.clip_by_bound()\\n\\n a.fit = function(a.position)\\n if a.fit < agent.fit:\\n agent.position = copy.deepcopy(a.position)\\n agent.fit = copy.deepcopy(a.fit)\",\n \"def initializeDistribution(self):\\n if (self.lowerBoundUsed == False and self.upperBoundUsed == False) or (self.min == self.lowerBound and self.max == self.upperBound):\\n self._distribution = distribution1D.BasicTriangularDistribution(self.apex,self.min,self.max)\\n else:\\n self.raiseAnError(IOError,'Truncated triangular not yet implemented')\",\n \"def update_probabilities(self):\\n self.probabilities = self.pheromones**self.EXP_PH * self.mcv**self.EXP_MCV\",\n \"def initializeDomainCondition(self):\\n print('Initialize the condition.')\\n\\n self.fluidPDF = np.zeros([self.typesFluids, self.ny, self.nx, 9])\\n self.fluidsDensity = np.zeros([self.typesFluids, self.ny, self.nx])\\n self.physicalVX = np.zeros([self.ny, self.nx])\\n self.physicalVY = np.zeros([self.ny, self.nx])\\n self.forceX = np.zeros([self.typesFluids, self.ny, self.nx])\\n self.forceY = np.zeros([self.typesFluids, self.ny, self.nx])\\n if (self.PictureExistance == \\\"'no'\\\"):\\n for i in sp.arange(self.ny):\\n for j in sp.arange(self.nx):\\n# for k in sp.arange(self.typesFluids):\\n tmpCenterX = int(self.nx / 2); tmpCenterY = int(self.ny / 2)\\n if (self.isDomain[i, j] == True):\\n# if (sp.sqrt((i - tmpCenterY) * (i - tmpCenterY) + (j - \\\\\\n# tmpCenterX) * (j - tmpCenterX)) <= 15.):\\n# if (i < 15 and np.abs(j - tmpCenterX) < 15):\\n# if ((i >0 and i < 28) and (j >=102 and j < 154)):\\n if (i < self.ny - 10):\\n# if (i < 128 and i > 70):\\n self.fluidsDensity[0, i, j] = self.initialDensities[0]\\n self.fluidPDF[0, i, j, :] = self.weightsCoeff * self.initialDensities[0]\\n self.fluidsDensity[1, i, j] = self.backgroundDensities[1]\\n self.fluidPDF[1, i, j, :] = self.weightsCoeff * self.backgroundDensities[1]\\n else:\\n self.fluidsDensity[1, i, j] = self.initialDensities[1]\\n self.fluidPDF[1, i, j, :] = self.weightsCoeff * self.initialDensities[1]\\n self.fluidsDensity[0, i, j] = self.backgroundDensities[0]\\n self.fluidPDF[0, i, j, :] = self.weightsCoeff * self.backgroundDensities[0] \\n \\n if (self.isCycles == \\\"'no'\\\" and self.PictureExistance == \\\"'yes'\\\"):\\n for i in sp.arange(self.ny):\\n for j in sp.arange(self.nx):\\n if (i < self.ny - 20):\\n # if ( np.abs(i - 60) < 20):\\n for k in sp.arange(self.typesFluids):\\n if (k == 0 and self.isDomain[i, j] == 1):\\n self.fluidPDF[k, i, j, :] = self.initialDensities[k] * self.weightsCoeff\\n self.fluidsDensity[k, i, j] = self.initialDensities[k]\\n if (k == 1 and self.isDomain[i, j] == 1):\\n self.fluidPDF[k, i, j, :] = self.backgroundDensities[k] * self.weightsCoeff\\n self.fluidsDensity[k, i, j] = self.backgroundDensities[k]\\n else:\\n for k in sp.arange(self.typesFluids):\\n if (k == 0 and self.isDomain[i, j] == 1):\\n self.fluidPDF[k, i, j, :] = self.backgroundDensities[k] * self.weightsCoeff\\n self.fluidsDensity[k, i, j] = self.backgroundDensities[k]\\n if (k == 1 and self.isDomain[i, j] == 1):\\n self.fluidPDF[k, i, j, :] = self.initialDensities[k] * self.weightsCoeff\\n self.fluidsDensity[k, i, j] = self.initialDensities[k]\\n elif (self.isCycles == \\\"'yes'\\\" and self.PictureExistance == \\\"'yes'\\\"):\\n username = getpass.getuser()\\n pathIniFile = '/home/' + username + '/LBMInitial/'\\n if (os.path.exists(pathIniFile) == True): \\n #for the old fluid distribution\\n #the domain of the network\\n iniFile = tb.open_file(pathIniFile + 'SimulationResults.h5', 'r')\\n for i in sp.arange(self.typesFluids-1):\\n self.fluidsDensity[i, :-30, :] = eval('iniFile.root.FluidMacro.FluidDensityType%gin%d[:-30, :]' % (i, self.lastStep))\\n self.fluidsDensity[i, -30:, :] = self.backgroundDensities[i]\\n for j in sp.arange(self.ny):\\n for k in sp.arange(self.nx):\\n self.fluidPDF[i, j, k, :] = self.weightsCoeff * \\\\\\n self.fluidsDensity[i, j, k]\\n iniFile.close()\\n# for the new fluid in the domain\\n for i in sp.arange(self.ny):\\n for j in sp.arange(self.nx):\\n if (i < self.ny - 30 and self.isDomain[i, j] == 1):\\n self.fluidsDensity[-1, i, j] = self.backgroundDensities[-1]\\n self.fluidPDF[-1, i, j, :] = self.backgroundDensities[-1] * \\\\\\n self.weightsCoeff\\n# continue\\n elif (i >= self.ny - 30 and self.isDomain[i, j] == 1):\\n self.fluidsDensity[-1, i, j] = self.initialDensities[-1]\\n self.fluidPDF[-1, i, j, :] = self.initialDensities[-1] * \\\\\\n self.weightsCoeff\\n else:\\n print(\\\"There is no file for initializing the domain.\\\")\\n sys.exit()\",\n \"def update_total_fpmu_dict(self):\\n # identical for each long-range connection\\n # extract parameters\\n deltat = self.dt\\n trise = self.tau_r\\n tdamp = self.tau_d\\n\\n tr = deltat/trise\\n etr = np.exp(-tr) \\n td = deltat/tdamp\\n etd = np.exp(-td)\\n cst = trise/(tdamp-trise)\\n\\n # nmda should keep in memory which could not be reset to zerooooooo!!!\\n \\\"\\\"\\\"\\n no resetting to zero --> go directly to refreshing !!! based on pre-value\\n \\\"\\\"\\\"\\n for c in self.source_connection_list:\\n if (c.conn_type == 'LongRange'):\\n self.total_INMDA_dict[c.connection_distribution] = self.total_INMDA_dict[c.connection_distribution] * etd + self.total_HNMDA_dict[c.connection_distribution] * cst\\n self.total_HNMDA_dict[c.connection_distribution] = self.total_HNMDA_dict[c.connection_distribution] * etr + c.curr_firing_rate * c.nsyn * c.weights * self.tau_r\\n\\n print 'Change HNMDA: ', c.curr_firing_rate * c.nsyn ,' \\\\n'\\n print 'Inputlr dict: ', self.total_inputlr_dict[c.connection_distribution]\\n\\n\\n\\n # for curr_CD in self.source_connection_list:\\n # have already exist\\n for c in self.source_connection_list:\\n if(c.conn_type == 'ShortRange'):\\n self.total_fpmu_dict[c.connection_distribution] = 0.0\\n # have already clear up all the short range connections\\n for c in self.source_connection_list:\\n if(c.conn_type == 'ShortRange'):\\n self.total_fpmu_dict[c.connection_distribution] += c.curr_firing_rate * c.nsyn * c.weights\\n\\n # summation\\n self.total_fp_vslave = 0.0\\n for key,val in self.total_fpmu_dict.items():\\n \\n try:\\n self.total_fp_vslave += val\\n except:\\n key.initialize()\\n self.total_fp_vslave += val\\n # and then, summation of Inmda\\n for key,val in self.total_INMDA_dict.items():\\n try:\\n self.total_fp_vslave += val\\n except:\\n key.initialize()\\n self.total_fp_vslave += val\\n # and then divided by gL or multiply tau_m\\n self.total_fp_vslave = self.total_fp_vslave * self.tau_m\",\n \"def update_weights(self):\\n\\t\\tpass\",\n \"def _UpdateCriteria(self):\\n grad = self.traj.grad[-1]\\n disp = self.traj.coords[-1] - self.traj.coords[-2]\\n self.delta_e = self.traj.energy[-1] - self.traj.energy[-2]\\n self.grad_max = numpy.amax(grad)\\n self.disp_max = numpy.amax(disp)\\n self.grad_rms = math.sqrt(numpy.mean(grad**2))\\n self.disp_rms = math.sqrt(numpy.mean(disp**2))\",\n \"def update_weights(self, inputVec, sigma, lrate, bmu):\\r\\n\\r\\n dist = self.get_nodeDistance(bmu)\\r\\n gauss = np.exp(-dist * dist / (2 * sigma * sigma))\\r\\n if gauss > 0:\\r\\n for i in range(len(self.weights)):\\r\\n self.weights[i] = self.weights[i] - gauss * lrate * (self.weights[i] - inputVec[i])\",\n \"def applyForce(self, F, dT):\",\n \"def _update(self):\\n self.cv.update()\",\n \"def updateForces(self):\\n for atom1 in range(0, self.numAtoms-1):\\n for atom2 in range(atom1+1, self.numAtoms):\\n self.calculateForce(atom1, atom2)\\n \\n # Multiply by constants \\n for atom in range(0, self.numAtoms):\\n self.atoms[atom].fx *= 48*self.e\\n self.atoms[atom].fy *= 48*self.e\\n self.atoms[atom].fz *= 48*self.e\\n self.atoms[atom].potential *= 4*self.e\",\n \"def update_counts(self, new_alpha, new_beta, decay):\\n\\n self._alpha = self._alpha / decay + new_alpha\\n self._beta = self._beta / decay + new_beta\\n self._n_updates += 1\",\n \"def update(self, es, **kwargs):\\n es.sigma *= self.update2(es, **kwargs)\\n if 11 < 3:\\n # derandomized MSR = natural gradient descent using mean(z**2) instead of mu*mean(z)**2\\n fit = kwargs['fit'] # == es.fit\\n slengths = np.array([sum(z**2) for z in es.arz[fit.idx[:es.sp.weights.mu]]])\\n # print lengths[0::int(es.sp.weights.mu/5)]\\n es.sigma *= np.exp(np.dot(es.sp.weights, slengths / es.N - 1))**(2 / (es.N + 1))\\n if 11 < 3:\\n es.more_to_write.append(10**((sum(self.ps**2) / es.N / 2 - 1 / 2 if es.opts['CSA_squared'] else _norm(self.ps) / es.const.chiN - 1)))\\n es.more_to_write.append(10**(-3.5 + sum(self.ps**2) / es.N / 2 - _norm(self.ps) / es.const.chiN))\\n # es.more_to_write.append(10**(-3 + sum(es.arz[es.fit.idx[0]]**2) / es.N))\",\n \"def handle_gradient(self):\\n self._optimizer.sync_grad()\",\n \"def __init__(self, mean=0.0, sigma=1.0):\\n super().__init__()\\n self.mean = mean\\n self.sigma = sigma\\n self.hasInfiniteBound = True\\n self.type = 'Normal'\\n self.distType = 'Continuous'\\n self.compatibleQuadrature.append('Hermite')\\n self.compatibleQuadrature.append('CDF')\\n #THESE get set in initializeDistribution, since it depends on truncation\\n #self.preferredQuadrature = 'Hermite'\\n #self.preferredPolynomials = 'Hermite'\",\n \"def update(self, x):\\n with torch.no_grad():\\n x_channel_first = x.to(self.dtype).transpose(0, 1).reshape(x.size(1), -1)\\n new_count = torch.full_like(self._count, x.size(0)).float()\\n new_mean = x_channel_first.mean(-1)\\n\\n if self._distributed:\\n distrib.all_reduce(new_count)\\n\\n new_mean = new_mean.float()\\n distrib.all_reduce(new_mean)\\n\\n # msg = torch.cat([new_mean, new_count.unsqueeze(-1)])\\n # distrib.all_reduce(msg)\\n # new_mean = msg[0:-1]\\n # new_count = msg[-1]\\n\\n new_mean /= distrib.get_world_size()\\n\\n # new_var = (x_channel_first - new_mean.view(x.size(1), -1)).pow(2).mean(-1)\\n new_var = (\\n x_channel_first - new_mean.view(x.size(1), -1).type_as(x)\\n ).pow(2).mean(-1, keepdim=True).float()\\n\\n if self._distributed:\\n distrib.all_reduce(new_var)\\n new_var /= distrib.get_world_size()\\n new_var = new_var.view(self._shape)\\n new_mean = new_mean.view(self._shape).float()\\n\\n self._mean, self._var, self._count = welford_update(\\n self._mean, self._var, self._count, new_mean, new_var, new_count,\\n )\",\n \"def update_total_fpsig_dict(self):\\n for curr_CD in self.total_inputsr_dict.keys():\\n self.total_fpsig_dict[curr_CD] = 0.0\\n for c in self.source_connection_list:\\n if(c.conn_type =='ShortRange'):\\n self.total_fpsig_dict[c.connection_distribution] += (c.curr_firing_rate) * (c.weights**2) * c.nsyn\\n\\n # summation\\n self.total_fp_sigv = 0.0\\n for key,val in self.total_fpsig_dict.items():\\n try:\\n self.total_fp_sigv += val\\n except:\\n key.initialize()\\n self.total_fp_sigv += val\\n self.total_fp_sigv = self.total_fp_sigv * self.tau_m\",\n \"def soft_update(self, other, tau):\\n new_weights = {}\\n\\n own_weights = self.get_weight_copies()\\n other_weights = other.get_weight_copies()\\n\\n for k in own_weights:\\n #print(own_weights[k].shape, other_weights[k].shape)\\n new_weights[k] = (1 - tau) * own_weights[k] + tau * other_weights[k]\\n self.set_weights(new_weights)\",\n \"def update(self):\\n\\n # get states, actions, rewards and total timesteps from memory\\n states, actions, R, T = self.memory.get()\\n n_ep = len(R)\\n\\n # compute value estimates for the states\\n v = self.critic(states)\\n\\n # compute advantages (using GAE) and rewards to go\\n A, rtg = utils.gae_rtg((R, v, T), self.gam, self.lam)\\n\\n # store the initial version of both the policy and the log probs of the\\n # actions for later comparison with the future versions (needed for PPO)\\n policy_old = copy.deepcopy(self.policy)\\n log_probs_old = policy_old(states).log_prob(actions)\\n\\n # sample from a batch of experiences\\n # (\\\"_\\\" subscript indicates \\\"sampled from\\\")\\n for (v_, A_, rtg_, log_probs_old_), i in utils.sample_batch((v, A, rtg, log_probs_old), self.batch_size, self.policy_updates):\\n log_probs_ = self.policy(states).log_prob(actions)[i]\\n\\n # estimate ratio between the new log probs and the old ones\\n r_ = torch.exp(log_probs_ - log_probs_old_)\\n\\n l_1 = r_ * A_\\n l_2 = torch.clamp(r_, 1-self.eps, 1+self.eps) * A_\\n\\n # TODO: implement entropy\\n # TODO: merge policy and critic\\n\\n # surragate loss function for PPO\\n l_clip = -torch.mean(torch.min(l_1, l_2))\\n\\n # update the policy\\n self.policy_optimizer.zero_grad()\\n l_clip.backward(retain_graph=True)\\n self.policy_optimizer.step()\\n\\n # sample a batch of value estimates and the corresponding rewards to go\\n # to update the value function.\\n for (v_, rtg_), _ in utils.sample_batch((v, rtg), self.batch_size, self.v_updates):\\n # compute the loss\\n critic_loss = F.mse_loss(v_, rtg_)\\n\\n # update the critic\\n self.critic_optimizer.zero_grad()\\n critic_loss.backward(retain_graph=True)\\n self.critic_optimizer.step()\\n\\n # clear the memory. PPO is an On-Policy method so we don't need these\\n # memories anymore\\n self.memory.clear()\\n\\n # return the loss of the value function for display\\n return F.mse_loss(v, rtg)\",\n \"def compute_updates(self, xs, gs, state=None):\\n raise NotImplementedError()\",\n \"def applyBoltzmannDist(self):\\n normDist = []\\n scaling_factor = math.sqrt(self.kb*self.temp/self.m)\\n\\n # Establish Normal Distribution\\n for i in range(0, 3*self.numAtoms):\\n normDist.append(random.gauss(0,1))\\n \\n # Apply scaling factor to distribution\\n for number in range(0, 3*self.numAtoms):\\n normDist[number] = normDist[number]*scaling_factor\\n \\n # Distribute velocities\\n for atom in range(0, self.numAtoms):\\n self.atoms[atom].vx = normDist[atom*3]\\n self.atoms[atom].vy = normDist[atom*3+1]\\n self.atoms[atom].vz = normDist[atom*3+2]\",\n \"def update_points(self, acqfunc_values, indices, dscale):\\n ind, val = self.checkvalues(indices, acqfunc_values)\\n new_start_idx = np.where(np.array(acqfunc_values) == val)[0][0]\\n acqfunc_values = np.array(acqfunc_values)[new_start_idx:]\\n indices = np.vstack(indices)[new_start_idx:]\\n acqfunc_values_ = copy.deepcopy(acqfunc_values)\\n minval = acqfunc_values.min()\\n new_max = acqfunc_values.max()\\n new_max_id = np.argmax(acqfunc_values)\\n max_val_all, max_id_all = [], []\\n ck = indices[new_max_id]\\n tree = spatial.cKDTree(indices)\\n while new_max > minval - 1:\\n max_val_all.append(new_max)\\n max_id_all.append(new_max_id)\\n nn_indices = tree.query_ball_point(ck, dscale)\\n acqfunc_values[nn_indices] = minval - 1\\n new_max = acqfunc_values.max()\\n new_max_id = np.argmax(acqfunc_values)\\n ck = indices[new_max_id]\\n max_val_all = max_val_all[:self.batch_out_max]\\n indices_ = indices[max_id_all].tolist()[:self.batch_out_max]\\n if len(indices_) < self.batch_out_max:\\n if self.verbose == 2:\\n print(\\\"Adding {} random indices\\\".format(\\n self.batch_out_max - len(indices_)))\\n idx_random = np.random.randint(\\n 0, len(acqfunc_values), self.batch_out_max - len(indices_))\\n indices_.extend(indices[idx_random].tolist())\\n max_val_all.extend(acqfunc_values_[idx_random].tolist())\\n return max_val_all, indices_\",\n \"def update2(self, es, **kwargs):\\n self._update_ps(es) # caveat: if es.B or es.D are already updated and ps is not, this goes wrong!\\n p = self.ps\\n try: pc_for_ps = 'pc for ps' in es.opts['vv'] # just in case\\n except: pc_for_ps = False # 'vv' has an incompatible format or does't exist\\n if pc_for_ps:\\n # was: es.D**-1 * np.dot(es.B.T, es.pc)\\n if es.opts['verbose'] > 5 and es.countiter == 1:\\n utils.print_message('pc for ps is active')\\n p = es.sm.transform_inverse(es.pc)\\n try: # to filter coordinates or a\\n p = es.path_for_sigma_update(p) # subspace depending on the state\\n except AttributeError:\\n if 11 < 3 and len(es.opts['integer_variables']):\\n m = (\\\"Missing ``path_for_sigma_update`` attribute in {}.\\\"\\n \\\"\\\\n This is usually not a problem unless integer mutations are used.\\\"\\n \\\"\\\".format(type(es)))\\n _warnings.warn(m)\\n N = len(p)\\n if N == 0: # all variables are masked, do nothing\\n return 1\\n if es.opts['CSA_squared']:\\n s = (sum(_square(p)) / N - 1) / 2\\n # sum(self.ps**2) / es.N has mean 1 and std sqrt(2/N) and is skewed\\n # divided by 2 to have the derivative d/dx (x**2 / N - 1) for x**2=N equal to 1\\n else:\\n s = _norm(p) / Mh.chiN(N) - 1\\n s *= self.cs / self.damps\\n s_clipped = Mh.minmax(s, -self.max_delta_log_sigma, self.max_delta_log_sigma)\\n # \\\"error\\\" handling\\n if s_clipped != s:\\n utils.print_warning('sigma change np.exp(' + str(s) + ') = ' + str(np.exp(s)) +\\n ' clipped to np.exp(+-' + str(self.max_delta_log_sigma) + ')',\\n 'update',\\n 'CMAAdaptSigmaCSA',\\n es.countiter, es.opts['verbose'])\\n self.delta *= np.exp(s_clipped)\\n return np.exp(s_clipped)\",\n \"def update_boundary(self):\\n\\n cell = self._fire_boundary.dequeue()\\n neighbors = self.four_neighbors(cell[0], cell[1])\\n #neighbors = self.eight_neighbors(cell[0], cell[1])\\n for neighbor in neighbors:\\n if self.is_empty(neighbor[0], neighbor[1]):\\n self.set_full(neighbor[0], neighbor[1])\\n self._fire_boundary.enqueue(neighbor)\\n\\n # Check class invariant after update\\n assert self.boundary_invariant()\",\n \"def perform_update(self, gradient):\\n w = sys.modules[self.shared_mem_name].__dict__[\\\"w\\\"]\\n w -= self.learning_rate * gradient\",\n \"def _update(self, bandit): \\n \\n bandit_logs = self.logging[bandit]\\n bandit = bandit.id\\n estimate = bandit_logs['reward'] / bandit_logs['actions'] # if not assigned\\n actions = bandit_logs['actions']\\n self.mu[bandit] = (self.mu_pri[bandit]/self.var_pri[bandit] + actions*estimate/self.var0)/(actions/self.var0 + 1/self.var_pri[bandit])\\n self.var[bandit] = 1/(actions/self.var0 + 1/self.var[bandit])\",\n \"def __init__(self, quantity, dist_weights, gauss_params, upper_bound, lower_bound):\\n self.dist_weights = dist_weights\\n self.lower_bound = lower_bound\\n self.upper_bound = upper_bound\\n if len(self.dist_weights) != len(gauss_params):\\n print(\\n \\\"Number of distribution weights do not match number of distributions!\\\"\\n )\\n diff = len(gauss_params) - len(dist_weights)\\n if diff < 0:\\n print(\\\"Ignoring trailing distribution weights\\\")\\n self.dist_weights = self.dist_weights[: len(dist_weights) + diff]\\n else:\\n print(\\\"Assuming default weights of 1\\\")\\n self.dist_weights.extend([1] * diff)\\n # normalize weights\\n self.dist_weights = np.array(\\n [float(i) / sum(self.dist_weights) for i in self.dist_weights]\\n )\\n # create samples\\n self.samples = []\\n self.gauss_params = gauss_params\\n sample_size = quantity\\n self.sample_min, self.sample_max = [float(\\\"inf\\\"), -float(\\\"inf\\\")]\\n while True:\\n # determine the gaussian to sample from for each sample\\n mixture_idx = np.random.choice(\\n len(self.dist_weights),\\n size=sample_size,\\n replace=True,\\n p=self.dist_weights,\\n )\\n # create the samples from the respective gaussian\\n temp = np.fromiter(\\n (ss.norm.rvs(*(gauss_params[i])) for i in mixture_idx), dtype=np.float64\\n )\\n # remember mixed sampled extremas for plotting\\n self.sample_min = min(self.sample_min, temp.min())\\n self.sample_max = max(self.sample_max, temp.max())\\n # add those samples that are within the bounds\\n self.samples = np.concatenate(\\n [\\n self.samples,\\n np.fromiter(\\n [x for x in temp if x <= upper_bound and x >= lower_bound],\\n dtype=np.float64,\\n ),\\n ]\\n )\\n sample_size = quantity - len(self.samples)\\n if sample_size == 0:\\n break\",\n \"def update_feq(self):\\n\\n sim = self.sim\\n\\n self.sim.kernels.update_feq_fluid(\\n sim.queue, sim.two_d_global_size, sim.two_d_local_size,\\n sim.feq.data,\\n sim.rho.data,\\n sim.u_bary.data, sim.v_bary.data,\\n sim.w, sim.cx, sim.cy, sim.cs,\\n sim.nx, sim.ny,\\n self.field_index, sim.num_populations,\\n sim.num_jumpers).wait()\",\n \"def _update_mean_and_sigma_inv_times_centered_y(self):\\n\\n if self._sigma_inv_times_centered_y is not None:\\n update_condition = (\\n len(self._sigma_inv_times_centered_y) != len(self.list_y)\\n )\\n else:\\n update_condition = self._mean_y is None\\n\\n if update_condition:\\n y, mean = self._solve_linear_system()\\n self._sigma_inv_times_centered_y = y\\n self._mean_y = mean\",\n \"def update(self):\\n with torch.no_grad():\\n self.preprocess_rollout()\\n \\n # DEEP-RL TUTORIALS: КОСТЫЛЬ\\n #self.advantages = self.returns[:-1] - self.values[:-1]\\n #self.advantages = (self.advantages - self.advantages.mean()) / (self.advantages.std() + 1e-5)\\n \\n # going through rollout several (config.epochs) times:\\n for epoch in range(self.config.epochs):\\n # TODO: drop last = False? What if there is 1 sample?\\n sampler = BatchSampler(SubsetRandomSampler(range(self.env.num_envs * self.config.rollout)), self.config.batch_size, drop_last=False)\\n \\n for indices in sampler:\\n # retrieving new batch as part of rollout\\n self.returns_b = self.returns.view(-1, *self.config.value_repr_shape)[indices]\\n self.old_values_b = self.values.view(-1, *self.config.value_repr_shape)[indices]\\n self.old_action_log_probs_b = self.action_log_probs.view(-1)[indices]\\n #self.advantages_b = self.advantages.view(-1)[indices] # КОСТЫЛЬ\\n \\n # calculating current value, action_log_prob, entropy\\n dist, self.values_b = self.policy(self.observations.view(-1, *self.config.observation_shape)[indices])\\n self.values_b = self.values_b.squeeze() # IMPORTANT ([32] - [32, 1] problem)\\n self.action_log_probs_b = dist.log_prob(self.actions.view(-1, *self.config.actions_shape)[indices])#.sum(dim=-1) \\n self.entropy_b = dist.entropy()#.sum(dim=-1)\\n \\n # performing step\\n self.gradient_ascent_step()\",\n \"def __call__(self):\\n\\n if self.indices is []:\\n return\\n\\n\\n #-----------------------------------------\\n # Here is where the important formula is applied\\n #----------------------------------------\\n if self.indices is None:\\n height = self.stage_c - self.elev_c\\n self.friction_c[:] = self.friction(height)\\n else:\\n ind = self.indices\\n height = self.stage_c[ind] - self.elev_c[ind]\\n self.friction_c[ind] = self.friction(height)\",\n \"def updateWeights(self,weightUpdate):\\n\\t\\n\\t\\tbranches = self.collectAllBranches()\\n\\n\\t\\tfor i in range(self.nBranches):\\n\\n\\t\\t\\tbranches[i].weight -= weightUpdate[i]\",\n \"def distribution(self, env):\\n pass\",\n \"def release_update(self, surfaces, release_state): \\n # Set the integrator to the release state.\\n self._s2 = (release_state['t'], release_state['q'], release_state['p'])\\n\\n # Remove the constraints from the system.\\n remove_constraints(self, surfaces)\\n #remove_list = []\\n #for con in self._state1_impacts:\\n # if con in self.system.constraints:\\n # remove_list.append(con)\\n #remove_constraints(self, remove_list) \\n\\n self._tau1 = TAU(self)\\n\\n # Step to the end of the current timestep.\\n if self.t_end != self.t2:\\n self.lambda0 = self.lambda1\\n self.step(self.t_end, k2=self.kin_config(self.t_end))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6606664","0.64178854","0.6225716","0.6151874","0.60961413","0.6093528","0.5998069","0.59092504","0.59061515","0.58915484","0.5869262","0.5866838","0.586291","0.58489245","0.5843187","0.583318","0.58013886","0.58013636","0.5791642","0.57863945","0.5767481","0.57557744","0.5754389","0.5701559","0.57010233","0.56807137","0.56449896","0.564237","0.56215686","0.5621086","0.5609206","0.5579228","0.5575479","0.55713016","0.5536762","0.5534049","0.5521215","0.551742","0.551603","0.550259","0.5497983","0.5497983","0.5497983","0.5497983","0.549058","0.5487118","0.5458709","0.5447477","0.54422826","0.5437541","0.54374605","0.54274577","0.540845","0.5391398","0.5386257","0.53856254","0.5366922","0.5363694","0.5361591","0.5352647","0.5343664","0.53358984","0.53215057","0.53149796","0.5313887","0.5308248","0.5305192","0.5299195","0.52902806","0.528335","0.52787745","0.5274094","0.52673584","0.5261606","0.5259322","0.52513695","0.52373683","0.52372396","0.5235126","0.5232755","0.5221332","0.5216878","0.52124304","0.52084476","0.52061546","0.5203358","0.5199113","0.51950645","0.5188124","0.5181876","0.5174351","0.51724446","0.5170913","0.51698476","0.51644784","0.5162108","0.51587075","0.5152973","0.51484823","0.5148099","0.5146405"],"string":"[\n \"0.6606664\",\n \"0.64178854\",\n \"0.6225716\",\n \"0.6151874\",\n \"0.60961413\",\n \"0.6093528\",\n \"0.5998069\",\n \"0.59092504\",\n \"0.59061515\",\n \"0.58915484\",\n \"0.5869262\",\n \"0.5866838\",\n \"0.586291\",\n \"0.58489245\",\n \"0.5843187\",\n \"0.583318\",\n \"0.58013886\",\n \"0.58013636\",\n \"0.5791642\",\n \"0.57863945\",\n \"0.5767481\",\n \"0.57557744\",\n \"0.5754389\",\n \"0.5701559\",\n \"0.57010233\",\n \"0.56807137\",\n \"0.56449896\",\n \"0.564237\",\n \"0.56215686\",\n \"0.5621086\",\n \"0.5609206\",\n \"0.5579228\",\n \"0.5575479\",\n \"0.55713016\",\n \"0.5536762\",\n \"0.5534049\",\n \"0.5521215\",\n \"0.551742\",\n \"0.551603\",\n \"0.550259\",\n \"0.5497983\",\n \"0.5497983\",\n \"0.5497983\",\n \"0.5497983\",\n \"0.549058\",\n \"0.5487118\",\n \"0.5458709\",\n \"0.5447477\",\n \"0.54422826\",\n \"0.5437541\",\n \"0.54374605\",\n \"0.54274577\",\n \"0.540845\",\n \"0.5391398\",\n \"0.5386257\",\n \"0.53856254\",\n \"0.5366922\",\n \"0.5363694\",\n \"0.5361591\",\n \"0.5352647\",\n \"0.5343664\",\n \"0.53358984\",\n \"0.53215057\",\n \"0.53149796\",\n \"0.5313887\",\n \"0.5308248\",\n \"0.5305192\",\n \"0.5299195\",\n \"0.52902806\",\n \"0.528335\",\n \"0.52787745\",\n \"0.5274094\",\n \"0.52673584\",\n \"0.5261606\",\n \"0.5259322\",\n \"0.52513695\",\n \"0.52373683\",\n \"0.52372396\",\n \"0.5235126\",\n \"0.5232755\",\n \"0.5221332\",\n \"0.5216878\",\n \"0.52124304\",\n \"0.52084476\",\n \"0.52061546\",\n \"0.5203358\",\n \"0.5199113\",\n \"0.51950645\",\n \"0.5188124\",\n \"0.5181876\",\n \"0.5174351\",\n \"0.51724446\",\n \"0.5170913\",\n \"0.51698476\",\n \"0.51644784\",\n \"0.5162108\",\n \"0.51587075\",\n \"0.5152973\",\n \"0.51484823\",\n \"0.5148099\",\n \"0.5146405\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":87191,"cells":{"query":{"kind":"string","value":"Move arrays needed to compute the boundary on the GPU memory."},"document":{"kind":"string","value":"def move2gpu(self):\n if self.generator.backend.upper() == \"LOOPY\":\n try:\n import pyopencl as cl\n import pyopencl.array # pylint: disable=unused-variable\n from .context import queue\n except ImportError:\n raise ImportError(\"Please install loo.py\")\n\n self.rhs = cl.array.to_device(queue, self.rhs)\n if hasattr(self, \"s\"):\n self.s = cl.array.to_device(\n queue, self.s\n ) # pylint: disable=attribute-defined-outside-init\n self.istore = cl.array.to_device(queue, self.istore)\n for i in range(len(self.iload)):\n self.iload[i] = cl.array.to_device(queue, self.iload[i])"},"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 _data_move_out_last_dim_lt_one_block(tik_inst, dst, src, data_pos_info):\n sub_axis_1, sub_axis_0, axis_0, axis_1, axis_2, out_offset = data_pos_info\n data_size_one_block = _get_elment_cnt_one_block(src.dtype)\n\n with tik_inst.if_scope(sub_axis_1 == 1):\n with tik_inst.if_scope(sub_axis_0 * axis_2 > data_size_one_block):\n sub_axis_0_2 = sub_axis_0 * axis_2\n sub_axis_0_block_align = sub_axis_0_2 // data_size_one_block\n left_data = sub_axis_0_2 % data_size_one_block\n tik_inst.data_move(dst[out_offset], src, 0, 1, sub_axis_0_block_align, 0, 0)\n with tik_inst.if_scope(left_data > 0):\n with tik_inst.new_stmt_scope():\n reg_temp = [tik_inst.Scalar(src.dtype)\n for i in ADDR_IDX_LIST[:data_size_one_block]]\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\n reg_temp[idx].set_as(src[sub_axis_0_2 - data_size_one_block + idx])\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\n src[idx].set_as(reg_temp[idx])\n tik_inst.data_move(dst[out_offset + sub_axis_0_2 - data_size_one_block],\n src, 0, 1, 1, 0, 0)\n with tik_inst.else_scope():\n # for case sub_axis_0 * axis_2 < data_size_one_block\n with tik_inst.if_scope(axis_0 * axis_1 * axis_2 > data_size_one_block):\n m_sub_axis_0 = _ceil_div(data_size_one_block, axis_2)\n sub_axis_0_2 = m_sub_axis_0 * axis_2\n sub_axis_0_block_align = sub_axis_0_2 // data_size_one_block\n left_data = sub_axis_0_2 % data_size_one_block\n tik_inst.data_move(dst[out_offset + (sub_axis_0 - m_sub_axis_0) * axis_2],\n src, 0, 1, sub_axis_0_block_align, 0, 0)\n with tik_inst.if_scope(left_data > 0):\n with tik_inst.new_stmt_scope():\n reg_temp = [tik_inst.Scalar(src.dtype)\n for i in ADDR_IDX_LIST[:data_size_one_block]]\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\n reg_temp[idx].set_as(src[sub_axis_0_2 - data_size_one_block + idx])\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\n src[idx].set_as(reg_temp[idx])\n tik_inst.data_move(dst[out_offset + sub_axis_0 * axis_2 -\n data_size_one_block],\n src, 0, 1, 1, 0, 0)\n with tik_inst.else_scope():\n # the shape size is not bigger than one block size\n tik_inst.data_move(dst[out_offset], src, 0, 1,\n _ceil_div(axis_0 * axis_1 * axis_2, data_size_one_block), 0, 0)\n\n with tik_inst.else_scope():\n with tik_inst.if_scope(sub_axis_1 * axis_0 * axis_2 > data_size_one_block):\n sub_axis_1_0_2 = sub_axis_1 * axis_0 * axis_2\n sub_axis_1_0_2_block_align = sub_axis_1_0_2 // data_size_one_block\n left_data = sub_axis_1_0_2 % data_size_one_block\n tik_inst.data_move(dst[out_offset], src, 0, 1, sub_axis_1_0_2_block_align, 0, 0)\n with tik_inst.if_scope(left_data > 0):\n with tik_inst.new_stmt_scope():\n reg_temp = [tik_inst.Scalar(src.dtype)\n for i in ADDR_IDX_LIST[:data_size_one_block]]\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\n reg_temp[idx].set_as(src[sub_axis_1_0_2 - data_size_one_block + idx])\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\n src[idx].set_as(reg_temp[idx])\n tik_inst.data_move(dst[out_offset + sub_axis_1_0_2 - data_size_one_block],\n src, 0, 1, 1, 0, 0)\n with tik_inst.else_scope():\n # to make sure move in data size is not less than one block\n with tik_inst.if_scope(axis_0 * axis_1 * axis_2 > data_size_one_block):\n m_sub_axis_1 = _ceil_div(data_size_one_block, axis_0 * axis_2)\n sub_axis_1_0_2 = m_sub_axis_1 * axis_0 * axis_2\n sub_axis_0_block_align = sub_axis_1_0_2 // data_size_one_block\n left_data = sub_axis_1_0_2 % data_size_one_block\n tik_inst.data_move(dst[out_offset + (sub_axis_1 - m_sub_axis_1) * axis_0 * axis_2],\n src, 0, 1, sub_axis_0_block_align, 0, 0)\n with tik_inst.if_scope(left_data > 0):\n with tik_inst.new_stmt_scope():\n reg_temp = [tik_inst.Scalar(src.dtype)\n for i in ADDR_IDX_LIST[:data_size_one_block]]\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\n reg_temp[idx].set_as(src[sub_axis_1_0_2 - data_size_one_block + idx])\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\n src[idx].set_as(reg_temp[idx])\n tik_inst.data_move(dst[out_offset + sub_axis_1 * axis_0 * axis_2 -\n data_size_one_block],\n src, 0, 1, 1, 0, 0)\n with tik_inst.else_scope():\n # the shape size is not bigger than one block size\n tik_inst.data_move(dst[out_offset], src, 0, 1,\n _ceil_div(axis_0 * axis_1 * axis_2, data_size_one_block), 0, 0)","def allocate_arrays(self):\n self.prng_state = np.random.get_state()\n # Generate arrays of random shape\n self.shape1 = np.random.randint(20, high=512, size=(2,))\n self.shape2 = np.random.randint(20, high=512, size=(2,))\n self.array1 = np.random.rand(*self.shape1).astype(np.float32)\n self.array2 = np.random.rand(*self.shape2).astype(np.float32)\n self.d_array1 = parray.to_device(self.queue, self.array1)\n self.d_array2 = parray.to_device(self.queue, self.array2)\n # Generate random offsets\n offset1_y = np.random.randint(2, high=min(self.shape1[0], self.shape2[0]) - 10)\n offset1_x = np.random.randint(2, high=min(self.shape1[1], self.shape2[1]) - 10)\n offset2_y = np.random.randint(2, high=min(self.shape1[0], self.shape2[0]) - 10)\n offset2_x = np.random.randint(2, high=min(self.shape1[1], self.shape2[1]) - 10)\n self.offset1 = (offset1_y, offset1_x)\n self.offset2 = (offset2_y, offset2_x)\n # Compute the size of the rectangle to transfer\n size_y = np.random.randint(2, high=min(self.shape1[0], self.shape2[0]) - max(offset1_y, offset2_y) + 1)\n size_x = np.random.randint(2, high=min(self.shape1[1], self.shape2[1]) - max(offset1_x, offset2_x) + 1)\n self.transfer_shape = (size_y, size_x)","def _move_in_one_more_block():\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx:\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx],\n src[w_offset + w_size * sub_h_idx], 0, 1, sub_w_block, 0, 0)\n # in order to avoid dirty data when multiple core\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block *\n (sub_h_align_block_size + sub_h_idx_1)],\n src[w_offset +\n w_size * (sub_h_size - data_cnt_one_block + sub_h_idx_1)],\n 0, 1, sub_w_block, 0, 0)","def trim2DArray(input_arr, threshold=0): \n\n print(input_arr.shape)\n ul_x, ul_y = calculateTrimOffsetForward(input_arr, threshold)\n lr_x, lr_y = calculateTrimOffsetBackward(input_arr, threshold)\n\n output_arr = input_arr[ul_y:lr_y, ul_x:lr_x]\n\n print(output_arr.shape)\n\n return (output_arr)","def _data_move_in_last_dim_lt_one_block(tik_inst, dst, src, data_pos_info):\n sub_axis_1, sub_axis_0, axis_0, axis_1, axis_2, in_offset = data_pos_info\n data_size_one_block = _get_elment_cnt_one_block(src.dtype)\n\n with tik_inst.if_scope(sub_axis_1 == 1):\n with tik_inst.if_scope(tik.any(sub_axis_0 * axis_2 >= data_size_one_block,\n axis_0 * axis_1 * axis_2 <= data_size_one_block)):\n with tik_inst.for_range(0, sub_axis_0) as sub_axis_0_idx:\n tik_inst.data_move(\n dst[sub_axis_0_idx * data_size_one_block],\n src[sub_axis_0_idx * axis_1 * axis_2 + in_offset],\n 0, 1, 1, 0, 0)\n with tik_inst.else_scope():\n # to make sure move in data size is not less than one block\n m_sub_axis_0 = _ceil_div(data_size_one_block, axis_2)\n with tik_inst.for_range(0, m_sub_axis_0) as m_sub_axis_0_idx:\n tik_inst.data_move(\n dst[m_sub_axis_0_idx * data_size_one_block],\n src[(m_sub_axis_0_idx + sub_axis_0 - m_sub_axis_0) * axis_1 * axis_2 +\n in_offset],\n 0, 1, 1, 0, 0)\n\n with tik_inst.else_scope():\n with tik_inst.if_scope(tik.any(sub_axis_1 * axis_0 * axis_2 >= data_size_one_block,\n axis_0 * axis_1 * axis_2 <= data_size_one_block)):\n with tik_inst.for_range(0, sub_axis_1) as sub_axis_1_idx:\n with tik_inst.for_range(0, sub_axis_0) as sub_axis_0_idx:\n tik_inst.data_move(\n dst[(sub_axis_0_idx + sub_axis_1_idx * sub_axis_0) * data_size_one_block],\n src[(sub_axis_0_idx * axis_1 + sub_axis_1_idx) * axis_2 + in_offset],\n 0, 1, 1, 0, 0)\n with tik_inst.else_scope():\n # to make sure move in data size is not less than one block\n m_sub_axis_1 = _ceil_div(data_size_one_block, axis_0 * axis_2)\n with tik_inst.for_range(0, m_sub_axis_1) as m_sub_axis_1_idx:\n with tik_inst.for_range(0, sub_axis_0) as sub_axis_0_idx:\n tik_inst.data_move(\n dst[(sub_axis_0_idx + m_sub_axis_1_idx * sub_axis_0) *\n data_size_one_block],\n src[(sub_axis_0_idx * axis_1 + sub_axis_1 - m_sub_axis_1 +\n m_sub_axis_1_idx) * axis_2 + in_offset],\n 0, 1, 1, 0, 0)","def _data_move_out_last_dim_be_one_block(tik_inst, dst, src, data_pos_info):\n\n sub_h_size, sub_w_size, c_size, h_size, w_size, out_offset = data_pos_info\n data_size_one_block = _get_elment_cnt_one_block(src.dtype)\n is_w_block_align = w_size % data_size_one_block == 0\n sub_w_block = sub_w_size // data_size_one_block\n sub_w_left = sub_w_size % data_size_one_block\n cw_block = c_size * w_size // data_size_one_block\n stride_len = cw_block - sub_w_block\n\n with tik_inst.if_scope(is_w_block_align):\n with tik_inst.if_scope(tik.any(stride_len > MTE_STRIDES, sub_h_size > REPEAT_LIMIT_MTE)):\n with tik_inst.for_range(0, sub_h_size) as sub_h_idx:\n tik_inst.data_move(dst[sub_h_idx * c_size * w_size + out_offset],\n src[sub_h_idx * sub_w_size],\n 0, 1, sub_w_block, 0, 0)\n with tik_inst.else_scope():\n tik_inst.data_move(dst[out_offset], src, 0, sub_h_size, sub_w_block, 0, stride_len)\n\n with tik_inst.else_scope():\n # suppose w_size > data_size_one_block\n with tik_inst.for_range(0, sub_h_size) as sub_h_idx:\n with tik_inst.if_scope(sub_w_block > 0):\n tik_inst.data_move(dst[sub_h_idx * c_size * w_size + out_offset],\n src[sub_h_idx * (sub_w_block + 1) * data_size_one_block],\n 0, 1, sub_w_block, 0, 0)\n with tik_inst.if_scope(sub_w_left > 0):\n tik_inst.data_move(dst[sub_h_idx * c_size * w_size + out_offset +\n sub_w_size - data_size_one_block],\n src[(sub_h_idx * (sub_w_block + 1) + sub_w_block) *\n data_size_one_block],\n 0, 1, 1, 0, 0)","def cleanup(self):\n self.subpixel, self.pixel = self.stepup(self.subpixel, self.pixel, AxisDistance.pixelsize)\n self.pixel, self.tile = self.stepup(self.pixel, self.tile, AxisDistance.tilesize)","def update(self):\n for i in range(self.min_y, self.max_y + 1):\n for j in range(self.min_x, self.max_x + 1):\n try:\n DIMENSIONAL_ARRAY[i-1][j-1] = self.lis[i-self.min_y][j-self.min_x]\n except IndexError:\n pass","def optimizeFluidArray(self):\n print(\"Run the function for optimization.\")\n self.fluidNodes = np.empty(self.voidSpace, dtype = np.int64)\n ySize = self.ny; xSize = self.nx\n print(\"Start to fill effective fluid nodes.\")\n tmpIndicesDomain = -np.ones(self.isDomain.shape, dtype = np.int64)\n tmpIndicesFN = 0\n for i in sp.arange(ySize):\n for j in sp.arange(xSize):\n if (self.isDomain[i, j] == 1):\n# if (self.effectiveDomain[i, j] == 255.):\n tmpIndices = i * xSize + j\n self.fluidNodes[tmpIndicesFN] = tmpIndices\n tmpIndicesDomain[i, j] = tmpIndicesFN\n tmpIndicesFN += 1\n self.neighboringNodes = np.zeros(self.fluidNodes.size * 8, dtype = np.int64)\n if self.interactionType == \"'EFS'\":\n if self.explicitScheme == 8:\n self.neighboringNodesISO8 = np.zeros(self.fluidNodes.size * 24, \\\n dtype = np.int64)\n elif self.explicitScheme == 10:\n self.neighboringNodesISO10 = np.zeros(self.fluidNodes.size * 36, \\\n dtype = np.int64)\n totalNodes = self.fluidNodes.size\n #use cuda to generate the array for neighboring nodes\n print(\"Start to fill neighboring nodes\")\n deviceFluidNodes = cuda.to_device(self.fluidNodes)\n devicetmpIndicesDomain = cuda.to_device(tmpIndicesDomain)\n# deviceIsDomain = cuda.to_device(self.isDomain)\n deviceNeighboringNodes = cuda.to_device(self.neighboringNodes)\n blockNumX = int(self.xDimension / self.threadNum) \n blockNumY = math.ceil(self.fluidNodes.size / self.xDimension)\n threadPerBlock1D = (self.threadNum, 1)\n grid = (blockNumX, blockNumY)\n\n fillNeighboringNodes[grid, threadPerBlock1D](totalNodes, self.nx, self.ny, \\\n self.xDimension, deviceFluidNodes, devicetmpIndicesDomain, \\\n deviceNeighboringNodes)\n self.neighboringNodes = deviceNeighboringNodes.copy_to_host()\n if self.interactionType == \"'EFS'\":\n if self.explicitScheme == 8:\n deviceNeighboringNodesISO8 = cuda.to_device(self.neighboringNodesISO8)\n fillNeighboringNodesISO8[grid, threadPerBlock1D](totalNodes, self.nx, self.ny, \\\n self.xDimension, deviceFluidNodes, devicetmpIndicesDomain, \\\n deviceNeighboringNodesISO8)\n self.neighboringNodesISO8 = deviceNeighboringNodesISO8.copy_to_host()\n elif self.explicitScheme == 10:\n deviceNeighboringNodesISO10 = cuda.to_device(self.neighboringNodesISO10)\n fillNeighboringNodesISO10[grid, threadPerBlock1D](totalNodes, self.nx, self.ny, \\\n self.xDimension, deviceFluidNodes, devicetmpIndicesDomain, \\\n deviceNeighboringNodesISO10)\n self.neighboringNodesISO10 = deviceNeighboringNodesISO10.copy_to_host()\n \n print(\"Redefine the fluid nodes.\")\n# cuda.current_context().trashing.clear()\n self.optFluidPDF = np.empty([self.typesFluids, self.fluidNodes.size, 9])\n self.optFluidRho = np.empty([self.typesFluids, self.fluidNodes.size])\n self.optMacroVelocity = np.zeros(self.fluidNodes.size)\n self.optMacroVelocityX = np.zeros(self.fluidNodes.size, dtype = np.float64)\n self.optMacroVelocityY = np.zeros(self.fluidNodes.size, dtype = np.float64)\n self.optForceX = np.zeros([self.typesFluids, self.fluidNodes.size], \\\n dtype = np.float64)\n self.optForceY = np.zeros([self.typesFluids, self.fluidNodes.size], \\\n dtype = np.float64)\n tmpDomain = np.array([i == 1 for i in self.isDomain.reshape(ySize * xSize)])\n for i in sp.arange(self.typesFluids):\n self.optFluidRho[i] = self.fluidsDensity.reshape(self.typesFluids, \\\n ySize * xSize)[i, tmpDomain]\n self.optFluidPDF[i] = self.fluidPDF.reshape(self.typesFluids, ySize * \\\n xSize, 9)[i, tmpDomain]","def setupGPUSwept(solver):\n solver.gpuBlock = (slice(0,solver.sharedShape[0],1),)+solver.gpuBlock\n getGPUReadBlockSwept(solver) #Finish creating gpuReadBlock here\n blockShape =[element.stop for element in solver.gpuBlock]\n blockShape[-1] += int(2*solver.blocksize[0]) #Adding 2 blocks in the column direction\n # Creating local GPU array with split\n grid = (int((blockShape[2])/solver.blocksize[0]),int((blockShape[3])/solver.blocksize[1])) #Grid size\n #Creating constants\n bsp = lambda x: int(numpy.prod(blockShape[x:])) #block shape product returned as an integer\n const_dict = ({\"NV\":blockShape[1],'SX':blockShape[2],'SY':blockShape[3],\"VARS\":bsp(2),\"TIMES\":bsp(1),\"MPSS\":solver.maxPyramidSize,\"MOSS\":solver.maxOctSize,\"OPS\":solver.operating,\"ITS\":solver.intermediate})\n solver.GPUArray = mallocGPUArray(blockShape) #Allocated GPU\n solver.localGPUArray = numpy.zeros(blockShape)\n #Building CUDA source code\n solver.gpu = io.buildGPUSource(solver.gpu)\n io.copyConstants(solver.gpu,const_dict) #This copys cpu constants not global constants\n solver.cpu.set_globals(*solver.globals,source_mod=solver.gpu)\n # Make GPU geometry\n solver.Up.initializeGPU(solver.gpu.get_function(\"UpPyramid\"),solver.blocksize,(grid[0],grid[1]-1))\n solver.Oct.initializeGPU(solver.gpu.get_function(\"Octahedron\"),solver.blocksize,(grid[0],grid[1]-1))\n solver.Down.initializeGPU(solver.gpu.get_function(\"DownPyramid\"),solver.blocksize,(grid[0],grid[1]-1))\n solver.Yb.initializeGPU(solver.gpu.get_function(\"YBridge\"),solver.blocksize,grid)\n solver.Xb.initializeGPU(solver.gpu.get_function(\"XBridge\"),solver.blocksize,grid)","def _data_move_in_last_dim_be_one_block(tik_inst, dst, src, data_pos_info):\n\n sub_h_size, sub_w_size, h_size, w_size, in_offset = data_pos_info\n data_size_one_block = _get_elment_cnt_one_block(src.dtype)\n is_w_block_align = w_size % data_size_one_block == 0\n sub_w_block = sub_w_size // data_size_one_block\n sub_w_left = sub_w_size % data_size_one_block\n w_block = w_size // data_size_one_block\n stride_len = w_block - sub_w_block\n\n with tik_inst.if_scope(is_w_block_align):\n with tik_inst.if_scope(tik.any(stride_len > MTE_STRIDES, sub_h_size > REPEAT_LIMIT_MTE)):\n with tik_inst.for_range(0, sub_h_size) as sub_h_idx:\n tik_inst.data_move(dst[sub_h_idx * sub_w_size],\n src[sub_h_idx * w_size + in_offset],\n 0, 1, sub_w_block, 0, 0)\n with tik_inst.else_scope():\n with tik_inst.if_scope(stride_len > 0):\n tik_inst.data_move(dst, src[in_offset], 0, sub_h_size, sub_w_block, stride_len, 0)\n with tik_inst.else_scope():\n tik_inst.data_move(dst, src[in_offset], 0, 1, sub_h_size * sub_w_block, 0, 0)\n\n with tik_inst.else_scope():\n # suppose w_size > data_size_one_block\n with tik_inst.for_range(0, sub_h_size) as sub_h_idx:\n with tik_inst.if_scope(sub_w_block > 0):\n tik_inst.data_move(dst[sub_h_idx * (sub_w_block + 1) * data_size_one_block],\n src[sub_h_idx * w_size + in_offset],\n 0, 1, sub_w_block, 0, 0)\n with tik_inst.if_scope(sub_w_left > 0):\n tik_inst.data_move(dst[(sub_h_idx * (sub_w_block + 1) + sub_w_block) *\n data_size_one_block],\n src[sub_h_idx * w_size + in_offset + sub_w_size -\n data_size_one_block],\n 0, 1, 1, 0, 0)","def test_cpy2d(self):\n # Reference\n o1 = self.offset1\n o2 = self.offset2\n T = self.transfer_shape\n logger.info(\"\"\"Testing D->D rectangular copy with (N1_y, N1_x) = %s,\n (N2_y, N2_x) = %s:\n array2[%d:%d, %d:%d] = array1[%d:%d, %d:%d]\"\"\" %\n (\n str(self.shape1), str(self.shape2),\n o2[0], o2[0] + T[0],\n o2[1], o2[1] + T[1],\n o1[0], o1[0] + T[0],\n o1[1], o1[1] + T[1]\n )\n )\n self.array2[o2[0]:o2[0] + T[0], o2[1]:o2[1] + T[1]] = self.array1[o1[0]:o1[0] + T[0], o1[1]:o1[1] + T[1]]\n kernel_args = (\n self.d_array2.data,\n self.d_array1.data,\n np.int32(self.shape2[1]),\n np.int32(self.shape1[1]),\n np.int32(self.offset2[::-1]),\n np.int32(self.offset1[::-1]),\n np.int32(self.transfer_shape[::-1])\n )\n wg = None\n ndrange = self.transfer_shape[::-1]\n self.program.cpy2d(self.queue, ndrange, wg, *kernel_args)\n res = self.d_array2.get()\n self.compare(res, self.array2)","def __copy2array(self):\n # extract gradient and bias\n w = self.init_layer.weight\n b = self.init_layer.bias\n self.params = [[w,b]] # save it to buffer\n if self.bpoints is not None:\n for d, x1 in zip(self.deltas, self.bpoints):\n y1 = w *x1 + b # find the endpoint of line segment (x1, y1)\n w = w + d # add on the delta to gradient\n b = y1 - w * x1 # find new bias of line segment\n self.params.append([w,b]) # add to buffer\n\n # create buffer\n self.wb = torch.zeros(len(self.params), len(self.params[0]))\n for i in range(self.wb.shape[0]):\n for j in range(self.wb.shape[1]):\n self.wb[i,j] = self.params[i][j]","def updateArrays(self):\n for channelNumber in range(0, 8):\n self.channels[channelNumber][self.currentPosition]=self._voltage_get(channelNumber)#update next element in each array\n self.currentPosition+=1\n if self.currentPosition>=self.numberOfPoints:#reset position to beginning when we hit max number of points (like rolling oscilloscope)\n self.currentPosition=0\n self.cursorXS = self.getCurrentPositionArray()\n #could also set the next points to NaN's to make a gap!","def batch_split(self) -> np.array:\n pass","def _data_move_out_mc_on_w(tik_inst, dst, src, data_pos_info):\n\n # sub_h_size is the original value without any change\n sub_h_size, sub_w_size, h_size, w_size, out_offset = data_pos_info\n data_size_one_block = _get_elment_cnt_one_block(src.dtype)\n\n def _sub_h_not_block_align_bigger_one_block():\n \"\"\"\n sub_h_size is not block align, sub_h_size is bigger than one block\n \"\"\"\n\n sub_h_block = sub_h_size // data_size_one_block\n with tik_inst.for_range(0, sub_w_size) as sub_w_idx_2:\n with tik_inst.if_scope(sub_h_block > 0):\n tik_inst.data_move(\n dst[out_offset + sub_w_idx_2 * h_size],\n src[sub_w_idx_2 * (sub_h_block + 1) * data_size_one_block],\n 0, 1, sub_h_block, 0, 0)\n # move in one more block for this case\n tik_inst.data_move(\n dst[out_offset + sub_w_idx_2 * h_size + sub_h_size - data_size_one_block],\n src[sub_w_idx_2 * (sub_h_block + 1) * data_size_one_block +\n sub_h_block * data_size_one_block],\n 0, 1, 1, 0, 0)\n\n with tik_inst.if_scope(sub_h_size == h_size):\n # the data order in ub is the expected order\n sub_hw_size = sub_h_size * sub_w_size\n with tik_inst.if_scope(h_size % data_size_one_block == 0):\n tik_inst.data_move(dst[out_offset],\n src,\n 0, 1, sub_hw_size // data_size_one_block, 0, 0)\n with tik_inst.else_scope():\n # sub_h_size is smaller than one block\n with tik_inst.if_scope(h_size < data_size_one_block):\n # the data_move will move 1 block at least\n with tik_inst.if_scope(sub_hw_size < data_size_one_block):\n tik_inst.data_move(dst[out_offset],\n src,\n 0, 1, 1, 0, 0)\n with tik_inst.else_scope():\n sub_hw_block = sub_hw_size // data_size_one_block\n tik_inst.data_move(dst[out_offset],\n src,\n 0, 1, sub_hw_block, 0, 0)\n # in order to avoid dirty data\n with tik_inst.new_stmt_scope():\n temp_reg = [tik_inst.Scalar(src.dtype)\n for i in ADDR_IDX_LIST[:data_size_one_block]]\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\n temp_reg[idx].set_as(src[sub_hw_size - data_size_one_block + idx])\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\n src[idx].set_as(temp_reg[idx])\n tik_inst.data_move(dst[out_offset + sub_hw_size - data_size_one_block],\n src, 0, 1, 1, 0, 0)\n with tik_inst.else_scope():\n # sub_h_size is not block align, sub_h_size is bigger than one block\n _sub_h_not_block_align_bigger_one_block()\n\n with tik_inst.else_scope():\n # h_size > sub_h_size, h_size is block align\n stride_cnt = (h_size - sub_h_size) // data_size_one_block\n with tik_inst.if_scope(tik.all(h_size % data_size_one_block == 0,\n stride_cnt <= MTE_STRIDES)):\n tik_inst.data_move(dst[out_offset],\n src,\n 0, sub_w_size, sub_h_size // data_size_one_block, 0, stride_cnt)\n with tik_inst.else_scope():\n # h_size is not block align, sub_h_size is block align\n with tik_inst.if_scope(sub_h_size % data_size_one_block == 0):\n with tik_inst.for_range(0, sub_w_size) as sub_w_idx:\n tik_inst.data_move(dst[out_offset + sub_w_idx * h_size],\n src[sub_w_idx * sub_h_size],\n 0, 1, sub_h_size // data_size_one_block, 0, 0)\n with tik_inst.else_scope():\n _sub_h_not_block_align_bigger_one_block()","def _compute_bc_space_data(\n grid, bary_grid, coarse_space, truncate_at_segment_edge, swapped_normals\n):\n from bempp.api.grid.grid import enumerate_vertex_adjacent_elements\n from scipy.sparse import coo_matrix\n\n coarse_support = _np.zeros(grid.entity_count(0), dtype=_np.bool_)\n coarse_support[coarse_space.support_elements] = True\n\n if not truncate_at_segment_edge:\n for global_dof_index in range(coarse_space.global_dof_count):\n local_dofs = coarse_space.global2local[global_dof_index]\n edge_index = grid.data().element_edges[local_dofs[0][1], local_dofs[0][0]]\n for v in range(2):\n vertex = grid.data().edges[v, edge_index]\n start = grid.vertex_neighbors.indexptr[vertex]\n end = grid.vertex_neighbors.indexptr[vertex + 1]\n for cell in grid.vertex_neighbors.indices[start:end]:\n coarse_support[cell] = True\n\n coarse_support_elements = _np.array([i for i, j in enumerate(coarse_support) if j])\n number_of_support_elements = len(coarse_support_elements)\n\n bary_support_elements = 6 * _np.repeat(coarse_support_elements, 6) + _np.tile(\n _np.arange(6), number_of_support_elements\n )\n\n support = _np.zeros(bary_grid.number_of_elements, dtype=_np.bool_)\n support[bary_support_elements] = True\n\n bary_support_size = len(bary_support_elements)\n\n bary_vertex_to_edge = enumerate_vertex_adjacent_elements(\n bary_grid, bary_support_elements, swapped_normals\n )\n\n edge_vectors = (\n bary_grid.vertices[:, bary_grid.edges[0, :]]\n - bary_grid.vertices[:, bary_grid.edges[1, :]]\n )\n\n edge_lengths = _np.linalg.norm(edge_vectors, axis=0)\n\n normal_multipliers = _np.repeat(coarse_space.normal_multipliers, 6)\n local2global = _np.zeros((bary_grid.number_of_elements, 3), dtype=\"uint32\")\n local_multipliers = _np.zeros((bary_grid.number_of_elements, 3), dtype=\"uint32\")\n\n local2global[support] = _np.arange(3 * bary_support_size).reshape(\n bary_support_size, 3\n )\n\n local_multipliers[support] = 1\n\n coarse_dofs = []\n bary_dofs = []\n values = []\n\n for global_dof_index in range(coarse_space.global_dof_count):\n local_dofs = coarse_space.global2local[global_dof_index]\n edge_index = grid.data().element_edges[local_dofs[0][1], local_dofs[0][0]]\n neighbors = grid.edge_neighbors[edge_index]\n other = neighbors[1] if local_dofs[0][0] == neighbors[0] else neighbors[0]\n if coarse_space.local_multipliers[local_dofs[0][0], local_dofs[0][1]] > 0:\n lower = local_dofs[0][0]\n upper = other\n else:\n lower = other\n upper = local_dofs[0][0]\n vertex1, vertex2 = grid.data().edges[:, edge_index]\n # Re-order the vertices so that they appear in anti-clockwise\n # order.\n for local_index, vertex_index in enumerate(grid.data().elements[:, upper]):\n if vertex_index == vertex1:\n break\n if vertex2 == grid.data().elements[(local_index - 1) % 3, upper]:\n vertex1, vertex2 = vertex2, vertex1\n\n # Get the local indices of vertex1 and vertex2 in upper and lower\n local_vertex1 = -1\n for index, value in enumerate(grid.data().elements[:, upper]):\n if value == vertex1:\n local_vertex1 = index\n break\n else:\n local_vertex1 = -1\n\n for index, value in enumerate(grid.data().elements[:, lower]):\n if value == vertex2:\n local_vertex2 = index\n break\n else:\n local_vertex2 = -1\n\n for vertex_index, bary_element, sign in [\n (vertex1, 6 * upper + 2 * local_vertex1, -1.0),\n (vertex2, 6 * lower + 2 * local_vertex2, 1.0),\n ]:\n # Find the reference element index in elements adjacent to that vertex\n for ind, elem in enumerate(bary_vertex_to_edge[vertex_index]):\n if bary_element == elem[0]:\n break\n\n # Now get all the relevant edges starting to count above\n # ind\n num_bary_elements = len(bary_vertex_to_edge[vertex_index])\n vertex_edges = []\n for index in range(num_bary_elements):\n elem_edge_pair = bary_vertex_to_edge[vertex_index][\n (index + ind) % num_bary_elements\n ]\n for n in range(1, 3):\n vertex_edges.append((elem_edge_pair[0], elem_edge_pair[n]))\n\n # We do not want the reference edge part of this list\n vertex_edges.pop(0)\n vertex_edges.pop(-1)\n\n # We now have a list of edges associated with the vertex counting from edge\n # after the reference edge onwards in anti-clockwise order. We can now\n # assign the coefficients\n\n nc = num_bary_elements // 2 # Number of elements on coarse grid\n # adjacent to vertex.\n\n count = 0\n for index, edge in enumerate(vertex_edges):\n if index % 2 == 0:\n count += 1\n elem_index, local_edge_index = edge[:]\n edge_length = edge_lengths[\n bary_grid.data().element_edges[local_edge_index, elem_index]\n ]\n bary_dofs.append(local2global[elem_index, local_edge_index])\n coarse_dofs.append(global_dof_index)\n values.append(sign * (nc - count) / (2 * nc * edge_length))\n sign *= -1\n\n # Now process the tangential rwgs close to the reference edge\n\n # Get the associated barycentric elements and fill the coefficients in\n # the matrix.\n\n bary_upper_minus = 6 * upper + 2 * local_vertex1\n bary_upper_plus = 6 * upper + 2 * local_vertex1 + 1\n bary_lower_minus = 6 * lower + 2 * local_vertex2\n bary_lower_plus = 6 * lower + 2 * local_vertex2 + 1\n\n # The edge that we need always has local edge index 2.\n # Can compute the edge length now.\n\n edge_length_upper = edge_lengths[\n bary_grid.data().element_edges[2, bary_upper_minus]\n ]\n edge_length_lower = edge_lengths[\n bary_grid.data().element_edges[2, bary_lower_minus]\n ]\n\n # Now assign the dofs in the arrays\n coarse_dofs.append(global_dof_index)\n coarse_dofs.append(global_dof_index)\n coarse_dofs.append(global_dof_index)\n coarse_dofs.append(global_dof_index)\n\n bary_dofs.append(local2global[bary_upper_minus, 2])\n bary_dofs.append(local2global[bary_upper_plus, 2])\n bary_dofs.append(local2global[bary_lower_minus, 2])\n bary_dofs.append(local2global[bary_lower_plus, 2])\n\n values.append(1.0 / (2 * edge_length_upper))\n values.append(-1.0 / (2 * edge_length_upper))\n values.append(-1.0 / (2 * edge_length_lower))\n values.append(1.0 / (2 * edge_length_lower))\n\n nentries = len(coarse_dofs)\n np_coarse_dofs = _np.zeros(nentries, dtype=_np.uint32)\n np_bary_dofs = _np.zeros(nentries, dtype=_np.uint32)\n np_values = _np.zeros(nentries, dtype=_np.float64)\n\n np_coarse_dofs[:] = coarse_dofs\n np_bary_dofs[:] = bary_dofs\n np_values[:] = values\n\n dof_transformation = coo_matrix(\n (np_values, (np_bary_dofs, np_coarse_dofs)),\n shape=(3 * bary_support_size, coarse_space.global_dof_count),\n dtype=_np.float64,\n ).tocsr()\n\n return (\n dof_transformation,\n support,\n normal_multipliers,\n local2global,\n local_multipliers,\n )","def _move_to_original_bounds(new_space: Hypercuboid, original_space: Hypercuboid) -> Hypercuboid:\n moved_bounds: Hypercuboid = []\n\n for new_interval, old_interval in zip(new_space, original_space):\n moved_bounds.append(shift_to_within_parameter_bounds(new_interval=new_interval, old_interval=old_interval))\n\n return moved_bounds","def boat_array_reduction(mesh, boat, **kwargs):\n # boat = d['boat']\n # print(d['mesh'])\n # mesh = d['mesh']\n boat_new = boat[0::10, 0::2]\n mesh_new = [mesh[i][0::10, 0::2] for i in range(2)]\n # print('reduction', boat_new.shape, mesh_new[0].shape, mesh_new[1].shape)\n return mesh_new, boat_new","def backward(ctx, gradPixels, dpointIdxMap, gradRhoMap, gradWsMap, gradIsBehind):\n pointIdxMap, bbPositionMap, isBehind, WsMap, rhoMap, depthMap, Ws, rhoValues, projPoints, cameraPoints, boundingBoxes, pixels, Ms = ctx.saved_tensors\n mergeThreshold = ctx.mergeThreshold\n focalLength = ctx.focalLength\n numPoint = ctx.numPoint\n considerZ = ctx.considerZ\n bbWidth = ctx.bbWidth\n bbHeight = ctx.bbHeight\n batchSize, height, width, topK, C = WsMap.shape\n if ctx.needs_input_grad[0]: # rho will not be backpropagated\n WsMap_ = torch.where(isBehind.unsqueeze(-1), torch.zeros(1, 1, 1, 1, 1, device=WsMap.device, dtype=WsMap.dtype), WsMap)\n totalIdxMap = pointIdxMap*bbHeight*bbWidth+bbPositionMap[:, :, :, :, 0]*bbWidth+bbPositionMap[:, :, :, :, 1]\n # TODO check dNormalizeddRho\n rhoMap_filtered = torch.where(isBehind, torch.zeros(1, 1, 1, 1, device=rhoMap.device, dtype=rhoMap.dtype), rhoMap)\n sumRho = torch.sum(rhoMap_filtered, dim=-1, keepdim=True)\n dNormalizeddRho = torch.where(rhoMap > 0, 1/sumRho-rhoMap/sumRho, rhoMap)\n dRho = _guided_scatter_maps(numPoint*bbWidth*bbHeight, dNormalizeddRho.unsqueeze(-1)*gradPixels.unsqueeze(3)*WsMap_, totalIdxMap, boundingBoxes)\n dRho = torch.sum(dRho, dim=-1)\n dRho = torch.reshape(dRho, (batchSize, numPoint, bbHeight, bbWidth))\n else:\n dRho = None\n\n if ctx.needs_input_grad[2]:\n # dPixels/dWs = Rho\n rhoMap_filtered = torch.where(isBehind, torch.zeros(1, 1, 1, 1, device=rhoMap.device, dtype=rhoMap.dtype), rhoMap)\n sumRho = torch.sum(rhoMap_filtered, dim=-1, keepdim=True)\n sumRho = torch.where(sumRho == 0, torch.zeros_like(sumRho), sumRho)\n rhoMap_normalized = rhoMap_filtered/sumRho\n # BxHxWx3 -> BxHxWxKx3 -> BxNx3\n dWs = _guided_scatter_maps(numPoint, gradPixels.unsqueeze(3)*rhoMap_normalized.unsqueeze(-1), pointIdxMap, boundingBoxes)\n else:\n dWs = None\n\n if ctx.needs_input_grad[3]:\n localWidth = ctx.localWidth\n localHeight = ctx.localHeight\n depthValues = cameraPoints[:, :, 2].contiguous()\n # B,N,1\n dIdp = torch.zeros_like(projPoints, device=gradPixels.device, dtype=gradPixels.dtype)\n dIdz = torch.zeros(1, numPoint, device=gradPixels.device, dtype=gradPixels.dtype)\n gamma = 0.1\n # rhoMap_filtered = torch.where(isBehind, torch.zeros(1, 1, 1, 1, device=rhoMap.device, dtype=rhoMap.dtype), rhoMap)\n # sumRho = torch.sum(rhoMap_filtered, dim=-1, keepdim=True)\n # rhoMap_normalized = rhoMap_filtered/sumRho\n # rhoMap_normalized = rhoMap_filtered/sumRho\n outputs = _visibility_reference_backward(focalLength, mergeThreshold, gamma, considerZ, localHeight, localWidth, 0,\n gradPixels, pointIdxMap, rhoMap, WsMap, depthMap, isBehind,\n pixels, boundingBoxes, projPoints, Ws, depthValues, rhoValues, Ms, dIdp, dIdz)\n dIdp, dIdz, debugTensor = outputs\n dIdcam = torch.zeros_like(cameraPoints)\n dIdcam[:, :, 2] = dIdz\n # saved_variables[\"dI\"] = gradPixels.detach().cpu()\n # saved_variables[\"dIdp\"] = saved_variables[\"dIdp\"].scatter_(1, saved_variables[\"renderable_idx\"].expand(-1, -1, dIdp.shape[-1]),\n # dIdp.cpu().detach())\n # saved_variables[\"projPoints\"] = saved_variables[\"projPoints\"].scatter_(1, saved_variables[\"renderable_idx\"].expand(-1,-1,dIdp.shape[-1]),\n # projPoints.cpu().detach())\n # saved_variables[\"dIdpMap\"] = debugTensor[:,:,:,:2].cpu().detach()\n else:\n dIdp = dIdcam = None\n\n return (None, None, dWs, dIdp, None, None, dIdcam, None, None, None, None, None, None, None, None, None, None)","def backward(ctx, gradPixels, dpointIdxMap, gradRhoMap, gradWsMap, gradIsBehind):\n pointIdxMap, bbPositionMap, isBehind, WsMap, rhoMap, depthMap, Ws, rhoValues, projPoints, cameraPoints, boundingBoxes, pixels, Ms = ctx.saved_tensors\n mergeThreshold = ctx.mergeThreshold\n focalLength = ctx.focalLength\n numPoint = ctx.numPoint\n considerZ = ctx.considerZ\n bbWidth = ctx.bbWidth\n bbHeight = ctx.bbHeight\n batchSize, height, width, topK, C = WsMap.shape\n if ctx.needs_input_grad[0]: # rho will not be backpropagated\n WsMap_ = torch.where(isBehind.unsqueeze(-1), torch.zeros(1, 1, 1, 1, 1, device=WsMap.device, dtype=WsMap.dtype), WsMap)\n totalIdxMap = pointIdxMap*bbHeight*bbWidth+bbPositionMap[:, :, :, :, 0]*bbWidth+bbPositionMap[:, :, :, :, 1]\n # TODO check dNormalizeddRho\n rhoMap_filtered = torch.where(isBehind, torch.zeros(1, 1, 1, 1, device=rhoMap.device, dtype=rhoMap.dtype), rhoMap)\n sumRho = torch.sum(rhoMap_filtered, dim=-1, keepdim=True)\n dNormalizeddRho = torch.where(rhoMap > 0, 1/sumRho-rhoMap/sumRho, rhoMap)\n dRho = _guided_scatter_maps(numPoint*bbWidth*bbHeight, dNormalizeddRho.unsqueeze(-1)*gradPixels.unsqueeze(3)*WsMap_, totalIdxMap, boundingBoxes)\n dRho = torch.sum(dRho, dim=-1)\n dRho = torch.reshape(dRho, (batchSize, numPoint, bbHeight, bbWidth))\n else:\n dRho = None\n\n if ctx.needs_input_grad[2]:\n # dPixels/dWs = Rho\n rhoMap_filtered = torch.where(isBehind, torch.zeros(1, 1, 1, 1, device=rhoMap.device, dtype=rhoMap.dtype), rhoMap)\n sumRho = torch.sum(rhoMap_filtered, dim=-1, keepdim=True)\n sumRho = torch.where(sumRho == 0, torch.zeros_like(sumRho), sumRho)\n rhoMap_normalized = rhoMap_filtered/sumRho\n # BxHxWx3 -> BxHxWxKx3 -> BxNx3\n dWs = _guided_scatter_maps(numPoint, gradPixels.unsqueeze(3)*rhoMap_normalized.unsqueeze(-1), pointIdxMap, boundingBoxes)\n else:\n dWs = None\n\n if ctx.needs_input_grad[3]:\n localWidth = ctx.localWidth\n localHeight = ctx.localHeight\n depthValues = cameraPoints[:, :, 2].contiguous()\n # B,N,1\n dIdp = torch.zeros_like(projPoints, device=gradPixels.device, dtype=gradPixels.dtype)\n dIdz = torch.zeros(1, numPoint, device=gradPixels.device, dtype=gradPixels.dtype)\n outputs = _visibility_backward(focalLength, mergeThreshold, considerZ,\n localHeight, localWidth,\n gradPixels, pointIdxMap, rhoMap, WsMap, depthMap, isBehind,\n pixels, boundingBoxes, projPoints, Ws, depthValues, rhoValues, dIdp, dIdz)\n dIdp, dIdz = outputs\n # outputs = _visibility_debug_backward(mergeThreshold, focalLength, considerZ,\n # localHeight, localWidth, 0,\n # gradPixels, pointIdxMap, rhoMap, WsMap, depthMap, isBehind,\n # pixels, boundingBoxes, projPoints, Ws, depthValues, rhoValues, dIdp, dIdz)\n # dIdp, dIdz, debugTensor = outputs\n\n dIdcam = torch.zeros_like(cameraPoints)\n dIdcam[:, :, 2] = dIdz\n # saved_variables[\"dI\"] = gradPixels.detach().cpu()\n # saved_variables[\"dIdp\"] = saved_variables[\"dIdp\"].scatter_(1, saved_variables[\"renderable_idx\"].expand(-1, -1, dIdp.shape[-1]),\n # dIdp.cpu().detach())\n # saved_variables[\"projPoints\"] = saved_variables[\"projPoints\"].scatter_(1, saved_variables[\"renderable_idx\"].expand(-1,-1,dIdp.shape[-1]),\n # projPoints.cpu().detach())\n # saved_variables[\"dIdpMap\"] = debugTensor[:,:,:,:2].cpu().detach()\n else:\n dIdp = dIdcam = None\n\n return (None, None, dWs, dIdp, None, None, dIdcam, None, None, None, None, None, None, None, None, None, None)","def offset_to_uvd(self, x):\n self.batch_size = x.shape[0]\n self.W = x.shape[2]\n self.H = x.shape[3] \n self.D = 5\n self.grid_size = self.W*self.H*self.D\n \n grid_linear = x.reshape(self.batch_size, 64, -1)\n\n index = torch.from_numpy(np.asarray(np.unravel_index(np.arange(self.grid_size), \n (self.W, self.H, self.D)))).type(torch.FloatTensor)\n u = index[0, :].unsqueeze(0).expand(21, -1)\n v = index[1, :].unsqueeze(0).expand(21, -1)\n z = index[2, :].unsqueeze(0).expand(21, -1)\n\n if self.device != \"cpu\":\n u = u.cuda()\n v = v.cuda()\n z = z.cuda()\n\n pred_uvd_no_offset = grid_linear[:, :63, :].reshape(self.batch_size, 21, 3, self.grid_size)\n pred_conf = grid_linear[:, 63, :].reshape(self.batch_size, self.W, self.H, self.D)\n pred_conf = torch.sigmoid(pred_conf)\n \n # middle finger root is hand root\n pred_uvd_no_offset[:, self.hand_root, :, :] = torch.sigmoid(pred_uvd_no_offset[:, self.hand_root, :, :])\n \n pred_uvd = pred_uvd_no_offset.clone().detach()\n pred_uvd[:, :, 0, :] = (pred_uvd[:, :, 0, :] + u) / self.W\n pred_uvd[:, :, 1, :] = (pred_uvd[:, :, 1, :] + v) / self.H\n pred_uvd[:, :, 2, :] = (pred_uvd[:, :, 2, :] + z) / self.D\n \n pred_uvd_no_offset = pred_uvd_no_offset.reshape(self.batch_size, 21, 3, self.W, self.H, self.D)\n \n return pred_uvd_no_offset, pred_uvd, pred_conf","def forward_mbr(self, eouts, elens, ys_ref, recog_params, idx2token):\n bs, xmax, xdim = eouts.size()\n nbest = recog_params.get('recog_beam_width')\n assert nbest >= 2\n assert idx2token is not None\n scaling_factor = 1.0\n training = self.training\n self.eval()\n with torch.no_grad():\n nbest_hyps_id, _, scores = self.beam_search(eouts, elens, params=recog_params, nbest=nbest, exclude_eos=True)\n exp_wer = 0\n nbest_hyps_id_batch = []\n grad_list = []\n for b in range(bs):\n nbest_hyps_id_b = [np.fromiter(y, dtype=np.int64) for y in nbest_hyps_id[b]]\n nbest_hyps_id_batch += nbest_hyps_id_b\n scores_b = np2tensor(np.array(scores[b], dtype=np.float32), eouts.device)\n probs_b_norm = torch.softmax(scaling_factor * scores_b, dim=-1)\n wers_b = np2tensor(np.array([(compute_wer(ref=idx2token(ys_ref[b]).split(' '), hyp=idx2token(nbest_hyps_id_b[n]).split(' '))[0] / 100) for n in range(nbest)], dtype=np.float32), eouts.device)\n exp_wer_b = (probs_b_norm * wers_b).sum()\n grad_list += [(probs_b_norm * (wers_b - exp_wer_b)).sum()]\n exp_wer += exp_wer_b\n exp_wer /= bs\n if training:\n self.train()\n eouts_expand = eouts.unsqueeze(1).expand(-1, nbest, -1, -1).contiguous().view(bs * nbest, xmax, xdim)\n elens_expand = elens.unsqueeze(1).expand(-1, nbest).contiguous().view(bs * nbest)\n ys_in, ys_out, ylens = append_sos_eos(nbest_hyps_id_batch, self.eos, self.eos, self.pad, eouts.device)\n dstates = self.zero_state(bs * nbest)\n cv = eouts.new_zeros(bs * nbest, 1, self.enc_n_units)\n self.score.reset()\n aw = None\n lmout, lmstate = None, None\n ys_emb = self.embed_token_id(ys_in)\n src_mask = make_pad_mask(elens_expand).unsqueeze(1)\n logits = []\n for i in range(ys_in.size(1)):\n if self.lm is not None:\n lmout, lmstate, _ = self.lm.predict(ys_in[:, i:i + 1], lmstate)\n dstates, cv, aw, attn_state, attn_v = self.decode_step(eouts_expand, dstates, cv, ys_emb[:, i:i + 1], src_mask, aw, lmout, mode='parallel')\n logits.append(attn_v)\n if self.attn_type in ['gmm', 'sagmm']:\n aw = attn_state['myu']\n logits = self.output(torch.cat(logits, dim=1))\n log_probs = torch.log_softmax(logits, dim=-1)\n eos = ys_in.new_zeros((1,)).fill_(self.eos)\n nbest_hyps_id_batch_pad = pad_list([torch.cat([np2tensor(y, eouts.device), eos], dim=0) for y in nbest_hyps_id_batch], self.pad)\n grad = eouts.new_zeros(bs * nbest, nbest_hyps_id_batch_pad.size(1), self.vocab)\n for b in range(bs):\n onehot = torch.eye(self.vocab)[nbest_hyps_id_batch_pad[b * nbest:(b + 1) * nbest]]\n grad[b * nbest:(b + 1) * nbest] = grad_list[b] * onehot\n grad = grad.masked_fill_((nbest_hyps_id_batch_pad == self.pad).unsqueeze(2), 0)\n loss_mbr = self.mbr(log_probs, nbest_hyps_id_batch_pad, exp_wer, grad)\n loss_ce = torch.zeros((1,), dtype=torch.float32, device=eouts.device)\n if self.mbr_ce_weight > 0:\n loss_ce = self.forward_att(eouts, elens, ys_ref)[0]\n loss_ce = loss_ce.unsqueeze(0)\n return loss_mbr, loss_ce","def update(self):\n self._g, self._B = self._constraint_assembler.preallocate_g_and_B(self._no_of_dofs_unconstrained,\n self._dofidxs(),\n self._no_of_constraints_by_object())","def _fp32_inner_last_dim_lt_one_block(axis_0_lp_index, sub_axis_0):\n\n # move data in\n in_offset = (block_idx * per_core_col_size +\n axis_1_lp_index * max_core_axis_size +\n axis_0_lp_index * max_no_core_axis_size * axis_1) * axis_2\n data_pos_info = (sub_axis_1, sub_axis_0, axis_0, axis_1, axis_2, in_offset)\n _data_move_in_last_dim_lt_one_block(tik_inst, ub_input, data_in, data_pos_info)\n\n # do transpose\n with tik_inst.new_stmt_scope():\n temp_sub_axis_1 = tik_inst.Scalar(\"int64\")\n temp_sub_axis_0 = tik_inst.Scalar(\"int64\")\n data_size_one_block = _get_elment_cnt_one_block(data_in.dtype)\n axis_1_0_2_size = axis_0 * axis_1 * axis_2\n sub_axis_1_0_2_size = sub_axis_1 * sub_axis_0 * axis_2\n\n # to avoid multiple core dirty data\n with tik_inst.if_scope(tik.all(sub_axis_1_0_2_size < data_size_one_block,\n axis_1_0_2_size > data_size_one_block)):\n with tik_inst.if_scope(sub_axis_1 == 1):\n temp_sub_axis_0.set_as(_ceil_div(data_size_one_block, axis_2))\n temp_sub_axis_1.set_as(sub_axis_1)\n with tik_inst.else_scope():\n temp_sub_axis_0.set_as(sub_axis_0)\n temp_sub_axis_1.set_as(_ceil_div(data_size_one_block,\n axis_0 * axis_2))\n with tik_inst.else_scope():\n temp_sub_axis_1.set_as(sub_axis_1)\n temp_sub_axis_0.set_as(sub_axis_0)\n\n sub_dim_size = (temp_sub_axis_1, temp_sub_axis_0, axis_2)\n _transpose_by_2_vnchwconv_not_last_dim(tik_inst, ub_input[ub_offset],\n ub_input, sub_dim_size)\n\n # move data out\n out_offset = ((block_idx * per_core_col_size +\n axis_1_lp_index * max_core_axis_size) * axis_0 +\n axis_0_lp_index * max_no_core_axis_size) * axis_2\n data_pos_info = (sub_axis_1, sub_axis_0, axis_0, axis_1, axis_2, out_offset)\n _data_move_out_last_dim_lt_one_block(tik_inst, data_out, ub_input[ub_offset],\n data_pos_info)","def move_grids(self, fld, comm, time):\n # To avoid discrepancies between processors, only the first proc\n # decides whether to send the data, and broadcasts the information.\n dz = comm.dz\n if comm.rank==0:\n # Move the continuous position of the moving window object\n self.zmin += self.v * (time - self.t_last_move)\n # Find the number of cells by which the window should move\n zmin_global_domain, zmax_global_domain = comm.get_zmin_zmax(\n local=False, with_damp=False, with_guard=False )\n n_move = int( (self.zmin - zmin_global_domain)/dz )\n else:\n n_move = None\n # Broadcast the information to all proc\n if comm.size > 1:\n n_move = comm.mpi_comm.bcast( n_move )\n\n # Move the grids\n if n_move != 0:\n # Move the global domain\n comm.shift_global_domain_positions( n_move*dz )\n # Shift the fields\n Nm = len(fld.interp)\n for m in range(Nm):\n # Modify the values of the corresponding z's\n fld.interp[m].zmin += n_move*fld.interp[m].dz\n fld.interp[m].zmax += n_move*fld.interp[m].dz\n # Shift/move fields by n_move cells in spectral space\n self.shift_spect_grid( fld.spect[m], n_move )\n\n # Because the grids have just been shifted, there is a shift\n # in the cell indices that are used for the prefix sum.\n if fld.use_cuda:\n fld.prefix_sum_shift += n_move\n # This quantity is reset to 0 whenever prefix_sum is recalculated\n\n # Prepare the positions of injection for the particles\n # (The actual creation of particles is done when the routine\n # exchange_particles of boundary_communicator.py is called)\n if comm.rank == comm.size-1:\n # Move the injection position\n self.z_inject += self.v * (time - self.t_last_move)\n # Take into account the motion of the end of the plasma\n self.z_end_plasma += self.v_end_plasma * (time - self.t_last_move)\n # Increment the number of particle cells to add\n nz_new = int( (self.z_inject - self.z_end_plasma)/dz )\n self.nz_inject += nz_new\n # Increment the virtual position of the end of the plasma\n # (When `generate_particles` is called, then the plasma\n # is injected between z_end_plasma - nz_inject*dz and z_end_plasma,\n # and afterwards nz_inject is set to 0.)\n self.z_end_plasma += nz_new*dz\n\n # Change the time of the last move\n self.t_last_move = time","def __init__process(self, n_cpu):\n global shared_slices\n global shared_data\n\n shared_slices_base = sharedctypes.RawArray(ctypes.c_double,\n self._projection.shape[0])\n shared_slices = np.frombuffer(shared_slices_base)\n shared_slices = shared_slices.reshape((len(self._q.R), -1))\n\n shared_grad_base = sharedctypes.RawArray(ctypes.c_double,\n self._projection.shape[0])\n shared_grad = np.frombuffer(shared_grad_base)\n shared_grad = shared_grad.reshape((len(self._q.R), -1))\n\n shared_data_base = mp.Array(ctypes.c_double,\n self._data.size,\n lock=False)\n shared_data = np.ctypeslib.as_array(shared_data_base)\n shared_data = shared_data.reshape(self._data.shape)\n shared_data[:] = self._data\n\n self._pool = mp.Pool(n_cpu)","def move_and_process_input(batch):\n x, y = batch\n x = x.to(device).float()\n y = torch.as_tensor(y).to(device)\n x = x.permute(0, -1, 1, 2, 3)\n return x, y","def _overlap_crop_forward(self, x, shave=10, min_size=100000, bic=None):\n n_GPUs = 1\n scale = self.config['dataset']['scale']\n b, c, h, w = x.size()\n h_half, w_half = h // 2, w // 2\n h_size, w_size = h_half + shave, w_half + shave\n lr_list = [\n x[:, :, 0:h_size, 0:w_size],\n x[:, :, 0:h_size, (w - w_size):w],\n x[:, :, (h - h_size):h, 0:w_size],\n x[:, :, (h - h_size):h, (w - w_size):w]]\n\n if bic is not None:\n bic_h_size = h_size*scale\n bic_w_size = w_size*scale\n bic_h = h*scale\n bic_w = w*scale\n \n bic_list = [\n bic[:, :, 0:bic_h_size, 0:bic_w_size],\n bic[:, :, 0:bic_h_size, (bic_w - bic_w_size):bic_w],\n bic[:, :, (bic_h - bic_h_size):bic_h, 0:bic_w_size],\n bic[:, :, (bic_h - bic_h_size):bic_h, (bic_w - bic_w_size):bic_w]]\n\n if w_size * h_size < min_size:\n sr_list = []\n for i in range(0, 4, n_GPUs):\n lr_batch = torch.cat(lr_list[i:(i + n_GPUs)], dim=0)\n if bic is not None:\n bic_batch = torch.cat(bic_list[i:(i + n_GPUs)], dim=0)\n\n sr_batch_temp = self.netG(lr_batch)\n\n if isinstance(sr_batch_temp, list):\n sr_batch = sr_batch_temp[-1]\n else:\n sr_batch = sr_batch_temp\n\n sr_list.extend(sr_batch.chunk(n_GPUs, dim=0))\n else:\n sr_list = [\n self._overlap_crop_forward(patch, shave=shave, min_size=min_size) \\\n for patch in lr_list\n ]\n\n h, w = scale * h, scale * w\n h_half, w_half = scale * h_half, scale * w_half\n h_size, w_size = scale * h_size, scale * w_size\n shave *= scale\n\n output = x.new(b, c, h, w)\n output[:, :, 0:h_half, 0:w_half] \\\n = sr_list[0][:, :, 0:h_half, 0:w_half]\n output[:, :, 0:h_half, w_half:w] \\\n = sr_list[1][:, :, 0:h_half, (w_size - w + w_half):w_size]\n output[:, :, h_half:h, 0:w_half] \\\n = sr_list[2][:, :, (h_size - h + h_half):h_size, 0:w_half]\n output[:, :, h_half:h, w_half:w] \\\n = sr_list[3][:, :, (h_size - h + h_half):h_size, (w_size - w + w_half):w_size]\n\n return output","def _update(self):\n self.parametrize_beam()\n self.update_ranks()\n self._points = tf.reshape(self._endpoint, (1, 2)) * tf.reshape(self._ranks, (-1, 1))","def reshape(self, bottom, top):\n\t\tpass","def recenter(obs, bot_norm):\n recentered = []\n for i in range(obs.shape[0]): ## iterate through envs\n one_obs = obs[i]\n piece = np.transpose(one_obs[:][57:57+4][:], (1,0,2))\n bg = np.zeros((64*2, 64, 3), dtype=np.uint8)\n diff_min = 100\n loc_min = -1\n for loc in range(64-3):\n block = piece[loc:loc+3]\n block = np.transpose(block, (1,0,2))\n diff = abs(np.sum(bot_norm - block/np.linalg.norm(block)))\n if diff < diff_min:\n diff_min = diff\n loc_min = loc\n blk = piece[loc_min:loc_min+3]\n #print(\"detected loc: \", loc_min)\n center = 62 - loc_min\n bg[center:center+64] = one_obs.transpose((1,0,2))\n recentered.append(bg.transpose((1,0,2)))\n recentered = np.array(recentered)\n return recentered\n # recentered = []\n # obs = tf.constant(obs, dtype=tf.float32)\n # for i in range(obs.shape[0]): ## iterate through envs\n # one_obs = obs[i]\n # piece = tf.transpose(one_obs[:][57:57+4][:], perm=[1,0,2])\n # bg = tf.Variable(tf.zeros((64*2, 64, 3), dtype=tf.float32))\n # diff_min = 100\n # loc_min = -1\n # for loc in range(64-3):\n # block = piece[loc:loc+3]\n # block = tf.transpose(block, perm=[1,0,2])\n # diff = tf.math.abs(tf.reduce_sum(bot_norm - block/tf.norm(block)))\n # evl = diff.eval() \n # if evl < diff_min:\n # diff_min = evl\n # loc_min = loc\n # blk = piece[loc_min:loc_min+3]\n # #print(\"detected loc: \", loc_min)\n # center = 62 - loc_min\n # bg[center:center+64].assign(tf.transpose(one_obs, perm=[1,0,2]))\n # recentered.append(tf.transpose(bg, perm=[1,0,2]))\n # recentered = tf.constant(recentered)\n # return recentered","def pc_output_buffers_full(self, *args) -> \"std::vector< float,std::allocator< float > >\":\n return _beamforming_swig.doaesprit_sptr_pc_output_buffers_full(self, *args)","def _data_move_in_mc_on_w(tik_inst, dst, src, data_pos_info):\n\n sub_h_size, sub_w_size, h_size, w_size, w_offset = data_pos_info\n data_cnt_one_block = _get_elment_cnt_one_block(src.dtype)\n sub_w_block = _ceil_div(sub_w_size, data_cnt_one_block)\n sub_h_align_block_size = sub_h_size // data_cnt_one_block * data_cnt_one_block\n sub_h_left = sub_h_size % data_cnt_one_block\n is_not_w_block_align = w_size % data_cnt_one_block > 0\n is_h_size_smaller_one_block = h_size < data_cnt_one_block\n\n def _move_in_one_more_block():\n \"\"\"\n move in one more block of h when h > sub_h and sub_h is not block align\n \"\"\"\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx:\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx],\n src[w_offset + w_size * sub_h_idx], 0, 1, sub_w_block, 0, 0)\n # in order to avoid dirty data when multiple core\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block *\n (sub_h_align_block_size + sub_h_idx_1)],\n src[w_offset +\n w_size * (sub_h_size - data_cnt_one_block + sub_h_idx_1)],\n 0, 1, sub_w_block, 0, 0)\n\n with tik_inst.if_scope(is_not_w_block_align):\n # sub_h is block align or h is not enough one block\n with tik_inst.if_scope(tik.any(sub_h_left == 0, is_h_size_smaller_one_block)):\n with tik_inst.for_range(0, sub_h_size) as sub_h_idx:\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx],\n src[w_offset + w_size * sub_h_idx], 0, 1, sub_w_block, 0, 0)\n with tik_inst.else_scope():\n _move_in_one_more_block()\n\n with tik_inst.else_scope():\n with tik_inst.if_scope(tik.any(sub_h_left == 0, is_h_size_smaller_one_block)):\n src_strides = w_size // data_cnt_one_block - sub_w_block\n # mte max strides value is 65535\n with tik_inst.if_scope(src_strides > MTE_STRIDES):\n with tik_inst.for_range(0, sub_h_size) as sub_h_idx_2:\n tik_inst.data_move(dst[sub_w_size * sub_h_idx_2],\n src[w_offset + w_size * sub_h_idx_2],\n 0, 1, sub_w_block, 0, 0)\n with tik_inst.else_scope():\n tik_inst.data_move(dst, src[w_offset], 0, sub_h_size, sub_w_block, src_strides, 0)\n with tik_inst.else_scope():\n _move_in_one_more_block()","def warp(x, flo):\n x=torch.squeeze(x,2)\n flo=torch.squeeze(flo,2)\n B, C, H, W = x.size()\n # mesh grid \n xx = torch.arange(0, W).view(1,-1).repeat(H,1)\n yy = torch.arange(0, H).view(-1,1).repeat(1,W)\n xx = xx.view(1,1,H,W).repeat(B,1,1,1)\n yy = yy.view(1,1,H,W).repeat(B,1,1,1)\n grid = torch.cat((xx,yy),1).float()\n\n #if x.is_cuda:\n # grid = grid.cuda()\n vgrid = torch.Tensor(grid).cuda() - flo.cuda()\n\n # scale grid to [-1,1] \n vgrid[:,0,:,:] = 2.0*vgrid[:,0,:,:].clone() / max(W-1,1)-1.0\n vgrid[:,1,:,:] = 2.0*vgrid[:,1,:,:].clone() / max(H-1,1)-1.0\n\n vgrid = vgrid.permute(0,2,3,1) \n #x=x.cuda()\n output = nn.functional.grid_sample(x, vgrid,mode='bilinear')\n mask = torch.Tensor(torch.ones(x.size())).cuda()\n mask = nn.functional.grid_sample(mask, vgrid,mode='bilinear')\n\n # if W==128:\n # np.save('mask.npy', mask.cpu().data.numpy())\n # np.save('warp.npy', output.cpu().data.numpy())\n \n mask[mask<0.9999] = 0\n mask[mask>0] = 1\n return torch.unsqueeze(output,2),torch.unsqueeze(mask,2)","def _process(self, data: np.ndarray) -> np.ndarray:\n\n # Step 1. Reorder the data.\n memory = self._reorder_iq(data)\n\n # Step 2. Subtract and take absolute value of consecutive IQ points in\n # the reordered memory.\n post_processed_memory = np.abs(np.diff(memory, axis=0))\n\n # The first element of the post-processed data is the first element\n # of the reordered memory from step 1.\n post_processed_memory = np.insert(post_processed_memory, 0, memory[0], axis=0)\n\n # Step 3. Order post-processed IQ points by circuit.\n iq_memory = [[] for _ in range(self._n_circuits)]\n for idx, iq_point in enumerate(post_processed_memory):\n iq_memory[idx % self._n_circuits].append(iq_point)\n\n return np.array(iq_memory)","def reshape(self, bottom, top):\r\n pass","def update_boundary(self):\n\n cell = self._fire_boundary.dequeue()\n neighbors = self.four_neighbors(cell[0], cell[1])\n #neighbors = self.eight_neighbors(cell[0], cell[1])\n for neighbor in neighbors:\n if self.is_empty(neighbor[0], neighbor[1]):\n self.set_full(neighbor[0], neighbor[1])\n self._fire_boundary.enqueue(neighbor)\n\n # Check class invariant after update\n assert self.boundary_invariant()","def full_batch(self):\n full_X, full_y = pad_sort_data(self.full_X, self.full_y)\n return full_X, full_y","def swipeBase (self) :\n grid = self.grid\n\n #we start by putting every tile up\n for columnNbr in range(4) :\n nbrZeros = 4 - np.count_nonzero(grid[:,columnNbr])\n\n for lineNbr in range(4) :\n counter = 0\n while (grid[lineNbr, columnNbr] == 0) and (counter < 4):\n counter += 1\n if np.count_nonzero(grid[lineNbr:4, columnNbr]) != 0 :\n for remainingLine in range (lineNbr, 3) :\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\n grid[3, columnNbr] = 0\n\n #now we do the additions\n for lineNbr in range(3) :\n if grid[lineNbr, columnNbr] == grid[lineNbr+1, columnNbr] :\n grid[lineNbr, columnNbr] *= 2\n for remainingLine in range (lineNbr+1, 3) :\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\n grid[3, columnNbr] = 0\n\n return (grid)","def reshape(self,bottom,top):\n pass","def prepare_rhs(self, simulation):\n\n nv = simulation.container.nv\n sorder = simulation.container.sorder\n nspace = [1] * (len(sorder) - 1)\n v = self.stencil.get_all_velocities()\n\n gpu_support = simulation.container.gpu_support\n\n for key, value in self.value_bc.items():\n if value is not None:\n indices = np.where(self.ilabel == key)\n # TODO: check the index in sorder to be the most contiguous\n nspace[0] = indices[0].size\n k = self.istore[0, indices]\n\n s = 1 - self.distance[indices]\n coords = tuple()\n for i in range(simulation.domain.dim):\n x = simulation.domain.coords_halo[i][self.istore[i + 1, indices]]\n x += s * v[k, i] * simulation.domain.dx\n x = x.ravel()\n for j in range(\n 1, simulation.domain.dim\n ): # pylint: disable=unused-variable\n x = x[:, np.newaxis]\n coords += (x,)\n\n m = Array(nv, nspace, 0, sorder, gpu_support=gpu_support)\n m.set_conserved_moments(simulation.scheme.consm)\n\n f = Array(nv, nspace, 0, sorder, gpu_support=gpu_support)\n f.set_conserved_moments(simulation.scheme.consm)\n\n args = coords\n if isinstance(value, types.FunctionType):\n func = value\n elif isinstance(value, tuple):\n func = value[0]\n args += value[1]\n\n if self.time_bc[key]:\n func(f, m, 0, *args)\n else:\n func(f, m, *args)\n\n simulation.equilibrium(m)\n simulation.m2f(m, f)\n\n if self.generator.backend.upper() == \"LOOPY\":\n f.array_cpu[...] = f.array.get()\n\n self.feq[:, indices[0]] = f.swaparray.reshape((nv, indices[0].size))\n\n if self.time_bc[key]:\n self.func.append(func)\n self.args.append(args)\n self.f.append(f)\n self.m.append(m)\n self.indices.append(indices[0])","def test_SetMultipleMovingLoadsReverseGeom(self):\n\n # create nodes\n second_coord = [1, 0, 0.0]\n self.mp.CreateNewNode(1, 0.0, 0.0, 0.0)\n self.mp.CreateNewNode(2, second_coord[0], second_coord[1], 0.0)\n\n # create condition\n self.mp.CreateNewCondition(\"MovingLoadCondition2D2N\", 1, [2, 1], self.mp.GetProperties()[1])\n\n parameters = self.base_parameters\n\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME,\n 0)\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.DELTA_TIME,\n 0.25)\n\n process = GMA.SetMultipleMovingLoadsProcess(self.mp, parameters)\n cond = self.cmp.GetCondition(2)\n\n # initialize and set load\n process.ExecuteInitialize()\n process.ExecuteInitializeSolutionStep()\n\n # initialise matrices\n lhs = KratosMultiphysics.Matrix(0, 0)\n rhs = KratosMultiphysics.Vector(0)\n\n # set load on node\n # cond.SetValue(SMA.MOVING_LOAD_LOCAL_DISTANCE, 0)\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\n\n self.checkRHS(rhs, [0.0, 0.0, 0.0, -2.0])\n\n # move load\n process.ExecuteFinalizeSolutionStep()\n process.ExecuteInitializeSolutionStep()\n\n # check if interpolation is done correctly\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\n\n self.checkRHS(rhs, [0.0, -0.5, 0.0, -1.5])","def _copy_to_gpu(self):\n self.dispatch('on_texture')","def _preprocessing(self):\n if self.resize:\n self.click_list = self._remapping_coord(self.click_list,\n self.input_size,\n self.orig_size)\n clickers = self._get_clickers(self.click_list)\n clicks_list = clickers.get_clicks()\n clicks_lists = self._points_transform([clicks_list], self.image_width)\n points_nd = self._get_points_nd(clicks_lists, self.net_clicks_limit)\n return points_nd","def _delayed_array_promotions(self):\n for x in self.__delayed_promotions:\n self._promote_family_array(*x)\n\n self.__delayed_promotions = []","def pc_input_buffers_full(self, *args) -> \"std::vector< float,std::allocator< float > >\":\n return _beamforming_swig.doaesprit_sptr_pc_input_buffers_full(self, *args)","def _gen_mem_pre(self):\n params = self._get_model_params()\n\n # because we cant easily get intermediate values from ONNX runtime\n # use the pytorch value\n mem_0 = np.zeros(2_850)\n mem_1 = np.zeros(2_925)\n\n flat_input = np.ndarray.flatten(list(self.input_.values())[0])\n\n mem_0[: len(flat_input)] = flat_input\n\n tensors = params + [mem_0, mem_1]\n flat_tensors = [np.ndarray.flatten(tensor) for tensor in tensors]\n\n self.mem_pre = [f\"{x}\\n\" for tensor in flat_tensors for x in tensor.tolist()]","def pin_memory(self):\r\n\r\n self.points = [in_tensor.pin_memory() for in_tensor in self.points]\r\n self.neighbors = [in_tensor.pin_memory() for in_tensor in self.neighbors]\r\n self.pools = [in_tensor.pin_memory() for in_tensor in self.pools]\r\n self.upsamples = [in_tensor.pin_memory() for in_tensor in self.upsamples]\r\n self.lengths = [in_tensor.pin_memory() for in_tensor in self.lengths]\r\n self.features = self.features.pin_memory()\r\n\r\n return self","def main():\n\n # Create an empty array to hold our points.\n n = gpuarray.zeros(shape=(x, y, z),\n dtype=gpuarray.vec.float3)\n\n # Populate the array with randomized points from the search space.\n for k in range(z):\n for j in range(y):\n for i in range(x):\n n[i, j, k] = gpuarray.vec.make_float3(random.uniform(-width, width),\n random.uniform(-height, height),\n random.uniform(-depth, depth))\n\n # Declare our elementwise CUDA kernel.\n mod = Elementwise(\n arguments=\"float3 pt, float3 *ns, float *rs\",\n operation=\"rs[i] = sqrt(pow(pt.x-ns[i].x,2)+pow(pt.y-ns[i].y,2)+pow(pt.z-ns[i].z,2))\",\n name=\"euclidean_distance\",\n preamble=\"#include <math.h>\"\n )\n\n # Declare an empty results array.\n r = gpuarray.zeros(shape=(50, 50, 2), dtype=numpy.float32)\n start = cuda.Event()\n end = cuda.Event()\n start.record()\n # Call the kernel with a randomize point from the search space.\n mod(gpuarray.vec.make_float3(random.uniform(-width, width),\n random.uniform(-height, height),\n random.uniform(-width, width)), n, r)\n end.record()\n end.synchronize()\n print((start.time_till(end)))\n print(r)","def move(self):\n x = y = z = 0.0\n for cell in self.cells:\n x += (cell.x)#*n\n y += (cell.y)#*n\n z += (cell.z)#*n\n np = float(len(self.cells))\n med = numpy.array([x/np,y/np,z/np])\n \n dists = []\n for cell in self.cells:\n d = (cell.x-self.x)**2+(cell.y-self.y)**2+(cell.z-self.z)**2\n d = numpy.sqrt(d)\n dists.append(d)\n #md = (cell.x-med[0])**2+(cell.y-med[1])**2+(cell.z-med[2])**2\n #dists[-1] = (dists[-1]+md)/2\n cell = self.cells[numpy.argmin(dists)]\n cc = numpy.array([cell.x, cell.y, cell.z])\n \n t = self.t\n if abs(self.dnp) * ( self.np-self.np_req) > 0:\n t = self.tr\n self.dcenter = (1-t)*(med-self.center + self.u*(cc-med))\n self.x,self.y,self.z = self.center = self.center + self.dcenter","def free_intermediate_arrays(self):\n self._mgx = None\n self._mgy = None\n self._mgz = None\n self._vander = None\n self._bkg_cube = None\n self._bkg_cube_dirty = True","def _cell_to_global(self, xy, wh):\n # grid setup\n line = tf.range(0, self.num_cells)\n rows = tf.reshape(line, [self.num_cells, 1])\n rows = tf.tile(rows, [1, self.num_cells])\n cols = tf.reshape(line, [1, self.num_cells])\n cols = tf.tile(cols, [self.num_cells, 1])\n grid = tf.stack([cols, rows], axis=-1)\n grid = tf.reshape(grid, [1, self.num_cells, self.num_cells, 1, 2])\n grid = tf.cast(grid, tf.float32)\n # box transformation\n xy += grid\n wh *= tf.reshape(self.anchors, [1, 1, 1, self.num_anchors, 2])\n return tf.concat([xy, wh], axis=-1) / self.num_cells","def _compute_boundaries_embedding(self, boundaries):\n # Check if boundaries have been determined before\n boundaries_hash = hash(boundaries[self.n_keep_dims:].tostring())\n if boundaries_hash in self.boundaries_cache:\n boundaries_embedded = \\\n np.array(self.boundaries_cache[boundaries_hash])\n boundaries_embedded[:self.n_keep_dims] = \\\n boundaries[:self.n_keep_dims] # Overwrite keep-dim's boundaries\n return boundaries_embedded\n\n # Determine boundaries on embedded space\n boundaries_embedded = \\\n np.empty((self.n_keep_dims + self.d_embedding, 2))\n boundaries_embedded[:self.n_keep_dims] = boundaries[:self.n_keep_dims]\n for dim in range(self.n_keep_dims,\n self.n_keep_dims + self.d_embedding):\n x_embedded = np.zeros(self.n_keep_dims + self.d_embedding)\n while True:\n x = self._manifold_to_dataspace(x_embedded)\n if np.sum(np.logical_or(\n x[self.n_keep_dims:] < boundaries[self.n_keep_dims:, 0],\n x[self.n_keep_dims:] > boundaries[self.n_keep_dims:,\n 1])) \\\n > (self.d_orig - self.n_keep_dims) / 2:\n break\n x_embedded[dim] -= 0.01\n boundaries_embedded[dim, 0] = x_embedded[dim]\n\n x_embedded = np.zeros(self.n_keep_dims + self.d_embedding)\n while True:\n x = self._manifold_to_dataspace(x_embedded)\n if np.sum(np.logical_or(\n x[self.n_keep_dims:] < boundaries[self.n_keep_dims:, 0],\n x[self.n_keep_dims:] > boundaries[self.n_keep_dims:, 1])) \\\n > (self.d_orig - self.n_keep_dims) / 2:\n break\n x_embedded[dim] += 0.01\n boundaries_embedded[dim, 1] = x_embedded[dim]\n\n self.boundaries_cache[boundaries_hash] = boundaries_embedded\n\n return boundaries_embedded","def data_move_case_zero(tik_instance, ub_ori, ub_trans,\n is_last, num_outer_axis, num_loop_time,\n loop_time, loop_col, loop_len):\n with tik_instance.if_scope(tik.all(loop_time ==\n self.dst_shape[-4] //\n loop_col - 1,\n self.dst_shape[-4] % loop_col ==\n 0)):\n is_last.set_as(1)\n num_data_one_loop = self.dst_shape[-4] * self.dst_shape[-3] * \\\n self.dst_shape[-2] * self.dst_shape[-1]\n src_ub_index = 0\n if self.src_shape[-1] % CUBE_SIZE != 0 or \\\n (self.src_shape[-1] - loop_len * CUBE_SIZE) // \\\n self.num_data > MAX_STRIDE_BLK:\n if self.src_shape[-2] % CUBE_SIZE != 0:\n with tik_instance.if_scope(num_loop_time ==\n self.dst_shape[-3] - 1):\n with tik_instance.for_range(0,\n self.src_shape[-2] %\n CUBE_SIZE) as num_cube_col:\n src_gm_index = num_outer_axis *\\\n self.src_shape[-1] * \\\n self.src_shape[-2] + \\\n (num_loop_time * CUBE_SIZE +\n num_cube_col) *\\\n self.src_shape[-1] + loop_time *\\\n loop_col * CUBE_SIZE\n tik_instance.data_move(ub_ori[loop_len *\n CUBE_SIZE *\n num_cube_col],\n self.src_gm[src_gm_index],\n 0, 1,\n loop_len * self.num_byte //\n 2, 0, 0)\n with tik_instance.else_scope():\n with tik_instance.for_range(0, CUBE_SIZE) \\\n as num_cube_col:\n src_gm_index = num_outer_axis * \\\n self.src_shape[-1] * \\\n self.src_shape[-2] + \\\n (num_loop_time * CUBE_SIZE +\n num_cube_col) *\\\n self.src_shape[-1] + loop_time *\\\n loop_col * CUBE_SIZE\n tik_instance.data_move(ub_ori[loop_len *\n CUBE_SIZE *\n num_cube_col],\n self.src_gm[src_gm_index],\n 0, 1,\n loop_len * self.num_byte //\n 2, 0, 0)\n else:\n with tik_instance.for_range(0, CUBE_SIZE) as num_cube_col:\n src_gm_index = num_outer_axis * self.src_shape[-1] * \\\n self.src_shape[-2] + \\\n (num_loop_time * CUBE_SIZE +\n num_cube_col) * self.src_shape[-1] + \\\n loop_time * loop_col * CUBE_SIZE\n tik_instance.data_move(ub_ori[loop_len * CUBE_SIZE *\n num_cube_col],\n self.src_gm[src_gm_index],\n 0, 1,\n loop_len * self.num_byte //\n 2, 0, 0)\n else:\n src_gm_index = num_outer_axis * self.src_shape[-1] * \\\n self.src_shape[-2] + num_loop_time *\\\n CUBE_SIZE * self.src_shape[-1] +\\\n loop_time * loop_col * CUBE_SIZE\n if self.src_shape[-2] % CUBE_SIZE != 0:\n with tik_instance.if_scope(num_loop_time ==\n self.dst_shape[-3] - 1):\n tik_instance.data_move(ub_ori[src_ub_index],\n self.src_gm[src_gm_index], 0,\n self.src_shape[-2] % CUBE_SIZE,\n loop_len * self.num_byte // 2,\n (self.src_shape[-1] -\n loop_len * CUBE_SIZE) //\n self.num_data,\n 0)\n with tik_instance.else_scope():\n tik_instance.data_move(ub_ori[src_ub_index],\n self.src_gm[src_gm_index],\n 0, CUBE_SIZE,\n loop_len * self.num_byte // 2,\n (self.src_shape[-1] -\n loop_len * CUBE_SIZE) //\n self.num_data,\n 0)\n else:\n tik_instance.data_move(ub_ori[src_ub_index],\n self.src_gm[src_gm_index],\n 0, CUBE_SIZE,\n loop_len * self.num_byte // 2,\n (self.src_shape[-1] - loop_len *\n CUBE_SIZE) // self.num_data, 0)\n self.data_rearrange_case_four(tik_instance, ub_ori,\n ub_trans, num_loop_time,\n loop_len, is_last)\n\n if((self.dst_shape[-3] - 1) * self.dst_shape[-1] *\n self.dst_shape[-2] // self.num_data > MAX_STRIDE_BLK):\n with tik_instance.for_range(0, loop_len) as \\\n num_col_cube:\n dst_gm_index = num_outer_axis * num_data_one_loop + \\\n num_loop_time * self.dst_shape[-1] * \\\n self.dst_shape[-2] + \\\n (loop_time * loop_col + num_col_cube) * \\\n self.dst_shape[-1] * self.dst_shape[-2] * \\\n self.dst_shape[-3]\n tik_instance.data_move(self.dst_gm[dst_gm_index],\n ub_trans[num_col_cube *\n CUBE_SIZE *\n (CUBE_SIZE + 1)],\n 0, 1,\n self.dst_shape[-1] *\n self.dst_shape[-2] //\n self.num_data,\n 0, 0)\n else:\n dst_gm_index = num_outer_axis * num_data_one_loop + \\\n num_loop_time * self.dst_shape[-1] * \\\n self.dst_shape[-2] + loop_time * \\\n loop_col * self.dst_shape[-1] * \\\n self.dst_shape[-2] * \\\n self.dst_shape[-3]\n tik_instance.data_move(self.dst_gm[dst_gm_index],\n ub_trans[0],\n 0, loop_len,\n self.dst_shape[-1] *\n self.dst_shape[-2] // self.num_data,\n self.num_byte // 2,\n (self.dst_shape[-3] - 1) *\n self.dst_shape[-1] *\n self.dst_shape[-2] // self.num_data)","def spatial_batchnorm_backward(dout, cache):\n dx, dgamma, dbeta = None, None, None\n\n #############################################################################\n # TODO: Implement the backward pass for spatial batch normalization. #\n # #\n # HINT: You can implement spatial batch normalization using the vanilla #\n # version of batch normalization defined above. Your implementation should #\n # be very short; ours is less than five lines. #\n #############################################################################\n pass\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n\n return dx, dgamma, dbeta","def spatial_batchnorm_backward(dout, cache):\r\n \tN, C, H, W = dout.shape\r\n dout_new = dout.transpose(0, 2, 3, 1).reshape(N*H*W, C)\r\n dx, dgamma, dbeta = batchnorm_backward(dout_new, cache)\r\n dx = dx.reshape(N, H, W, C).transpose(0, 3, 1, 2)\r\n\r\n return dx, dgamma, dbeta","def data_move_case_zero(self, tik_instance, ub_ori, ub_cast_fp16, ub_trans,\n ub_cast_int8, is_last, num_outer_axis,\n num_loop_time, loop_time, loop_col, loop_len):\n with tik_instance.if_scope(tik.all(loop_time == self.dst_shape[-4] //\n loop_col - 1,\n self.dst_shape[-4] % loop_col ==\n 0)):\n is_last.set_as(1)\n num_data_one_loop = self.dst_shape[-4] * self.dst_shape[-3] * \\\n self.dst_shape[-2] * self.dst_shape[-1]\n src_ub_index = 0\n if self.src_shape[-1] % CUBE_SIZE_2 != 0 or \\\n (self.src_shape[-1] - loop_len * CUBE_SIZE_2) // \\\n self.num_data > MAX_STRIDE_BLK:\n with tik_instance.if_scope(num_loop_time ==\n self.dst_shape[-3] - 1):\n if self.src_shape[-2] % CUBE_SIZE != 0:\n with tik_instance.for_range(0, self.src_shape[-2] %\n CUBE_SIZE) as num_cube_col:\n src_gm_index = num_outer_axis * self.src_shape[-1] * \\\n self.src_shape[-2] + \\\n (num_loop_time * CUBE_SIZE +\n num_cube_col) * self.src_shape[-1] + \\\n loop_time * loop_col * CUBE_SIZE_2\n tik_instance.data_move(ub_ori[loop_len *\n CUBE_SIZE_2 *\n num_cube_col],\n self.src_gm[src_gm_index],\n 0, 1,\n loop_len * CUBE_SIZE_2 //\n self.num_data, 0, 0)\n else:\n with tik_instance.for_range(0, CUBE_SIZE) \\\n as num_cube_col:\n src_gm_index = num_outer_axis * self.src_shape[-1] * \\\n self.src_shape[-2] + \\\n (num_loop_time * CUBE_SIZE +\n num_cube_col) * self.src_shape[-1] + \\\n loop_time * loop_col * CUBE_SIZE_2\n tik_instance.data_move(ub_ori[loop_len *\n CUBE_SIZE_2 *\n num_cube_col],\n self.src_gm[src_gm_index],\n 0, 1,\n loop_len * CUBE_SIZE_2 //\n self.num_data, 0, 0)\n with tik_instance.else_scope():\n with tik_instance.for_range(0, CUBE_SIZE) as num_cube_col:\n src_gm_index = num_outer_axis * self.src_shape[-1] * \\\n self.src_shape[-2] + \\\n (num_loop_time * CUBE_SIZE +\n num_cube_col) * self.src_shape[-1] + \\\n loop_time * loop_col * CUBE_SIZE_2\n tik_instance.data_move(ub_ori[loop_len * CUBE_SIZE_2 *\n num_cube_col],\n self.src_gm[src_gm_index],\n 0, 1,\n loop_len * CUBE_SIZE_2 //\n self.num_data, 0, 0)\n else:\n src_gm_index = num_outer_axis * self.src_shape[-1] * \\\n self.src_shape[-2] + num_loop_time * CUBE_SIZE * \\\n self.src_shape[-1] + loop_time * loop_col * \\\n CUBE_SIZE_2\n with tik_instance.if_scope(num_loop_time ==\n self.dst_shape[-3] - 1):\n if self.src_shape[-2] % CUBE_SIZE != 0:\n tik_instance.data_move(ub_ori[src_ub_index],\n self.src_gm[src_gm_index], 0,\n self.src_shape[-2] % CUBE_SIZE,\n loop_len,\n (self.src_shape[-1] -\n loop_len * CUBE_SIZE_2) //\n self.num_data,\n 0)\n else:\n tik_instance.data_move(ub_ori[src_ub_index],\n self.src_gm[src_gm_index],\n 0, CUBE_SIZE,\n loop_len,\n (self.src_shape[-1] -\n loop_len * CUBE_SIZE_2) //\n self.num_data,\n 0)\n with tik_instance.else_scope():\n tik_instance.data_move(ub_ori[src_ub_index],\n self.src_gm[src_gm_index],\n 0, CUBE_SIZE,\n loop_len,\n (self.src_shape[-1] - loop_len *\n CUBE_SIZE_2) // self.num_data, 0)\n\n self.data_rearrange_case_one(tik_instance, ub_ori, ub_cast_fp16,\n ub_trans, ub_cast_int8, num_loop_time,\n loop_len, is_last)\n\n if((self.dst_shape[-3] - 1) * self.dst_shape[-1] *\n self.dst_shape[-2] // self.num_data > MAX_STRIDE_BLK):\n with tik_instance.for_range(0, loop_len) as \\\n num_col_cube:\n dst_gm_index = num_outer_axis * num_data_one_loop + \\\n num_loop_time * self.dst_shape[-1] * \\\n self.dst_shape[-2] + \\\n (loop_time * loop_col + num_col_cube) * \\\n self.dst_shape[-1] * self.dst_shape[-2] * \\\n self.dst_shape[-3]\n tik_instance.data_move(self.dst_gm[dst_gm_index],\n ub_cast_int8[num_col_cube *\n CUBE_SIZE_2 *\n (CUBE_SIZE + 1)],\n 0, 1,\n self.dst_shape[-1] *\n self.dst_shape[-2] //\n self.num_data,\n 0, 0)\n else:\n dst_gm_index = num_outer_axis * num_data_one_loop + \\\n num_loop_time * self.dst_shape[-1] * \\\n self.dst_shape[-2] + loop_time * \\\n loop_col * self.dst_shape[-1] * \\\n self.dst_shape[-2] * \\\n self.dst_shape[-3]\n tik_instance.data_move(self.dst_gm[dst_gm_index],\n ub_cast_int8[0],\n 0, loop_len,\n self.dst_shape[-1] * self.dst_shape[-2] //\n self.num_data, self.num_byte,\n (self.dst_shape[-3] - 1) *\n self.dst_shape[-1] *\n self.dst_shape[-2] // self.num_data)","def local_to_global(npboxes: np.ndarray, window: Box):\n xmin = window.xmin\n ymin = window.ymin\n return npboxes + np.array([[ymin, xmin, ymin, xmin]])","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def reshape(self, bottom, top):\n pass","def _process_operations(self, operations: List[MemoryOperation], slices: SlicesType = None) -> None:\n for op in operations:\n if op.inst == MemoryOperation.NOOP:\n pass # do nothing\n elif op.inst == MemoryOperation.LOAD:\n if MemoryOperation.LOAD_SUBARRAY in op.flag:\n # build slices mapping first\n self._array.set_slices_mapping(op.dst, slices)\n\n # check flag to see if dst is current device\n dst_is_current_device = op.flag != MemoryOperation.SWITCH_DEVICE_FLAG\n\n # copy data\n if num_gpu > 0:\n cupy.cuda.stream.get_current_stream().synchronize()\n \n self._array.copy_data_between_device(\n op.dst, op.src, dst_is_current_device)\n\n # sync stream before set it as ready, so asyc call is ensured to be done\n if num_gpu > 0:\n cupy.cuda.stream.get_current_stream().synchronize()\n elif op.inst == MemoryOperation.EVICT:\n # decrement the reference counter, relying on GC to free the memor\n self._array.clear(op.src)\n elif op.inst == MemoryOperation.ERROR:\n raise RuntimeError(\"PArray gets an error from coherence protocol\")\n else:\n raise RuntimeError(f\"PArray gets invalid memory operation from coherence protocol, \"\n f\"detail: opcode {op.inst}, dst {op.dst}, src {op.src}\")","def grid_displacement_pc(grid1, grid2, field, level, return_value=\"pixels\"):\n # create copies of the data\n field_data1 = grid1.fields[field][\"data\"][level].copy()\n field_data2 = grid2.fields[field][\"data\"][level].copy()\n\n # replace fill values with valid_min or minimum value in array\n if \"valid_min\" in grid1.fields[field]:\n min_value1 = grid1.fields[field][\"valid_min\"]\n else:\n min_value1 = field_data1.min()\n field_data1 = np.ma.filled(field_data1, min_value1)\n\n if \"valid_min\" in grid2.fields[field]:\n min_value2 = grid2.fields[field][\"valid_min\"]\n else:\n min_value2 = field_data2.min()\n field_data2 = np.ma.filled(field_data2, min_value2)\n\n # discrete fast fourier transformation and complex conjugation of field 2\n image1fft = np.fft.fft2(field_data1)\n image2fft = np.conjugate(np.fft.fft2(field_data2))\n\n # inverse fourier transformation of product -> equal to cross correlation\n imageccor = np.real(np.fft.ifft2(image1fft * image2fft))\n\n # shift the zero-frequency component to the center of the spectrum\n imageccorshift = np.fft.fftshift(imageccor)\n\n # determine the distance of the maximum from the center\n # find the peak in the correlation\n row, col = field_data1.shape\n yshift, xshift = np.unravel_index(np.argmax(imageccorshift), (row, col))\n yshift -= int(row / 2)\n xshift -= int(col / 2)\n\n dx = grid1.x[\"data\"][1] - grid1.x[\"data\"][0]\n dy = grid1.y[\"data\"][1] - grid1.y[\"data\"][0]\n x_movement = xshift * dx\n y_movement = yshift * dy\n\n if return_value == \"pixels\":\n displacement = (yshift, xshift)\n elif return_value == \"distance\":\n displacement = (y_movement, x_movement)\n elif return_value == \"velocity\":\n t1 = num2date(grid1.time[\"data\"][0], grid1.time[\"units\"])\n t2 = num2date(grid2.time[\"data\"][0], grid2.time[\"units\"])\n dt = (t2 - t1).total_seconds()\n u = x_movement / dt\n v = y_movement / dt\n displacement = (v, u)\n else:\n displacement = (yshift, xshift)\n return displacement","def _fp32_1_0_2_mc_on_1_last_dim_lt_one_block(loop_cnt, left_data):\n\n # two case:\n # 1. axis_0 * axis_2 > alloc_ub_size // 2, max_core_axis_size = 1\n # 2. axis_0 * axis_2 <= alloc_ub_size // 2, axis_0_loop_cnt = 0, max_core_axis_size != 1\n\n def _fp32_mte_process_lt_one_block(axis_1_lp_index, sub_axis_1):\n \"\"\"\n do transpose for last dim less than one block\n \"\"\"\n\n def _fp32_inner_last_dim_lt_one_block(axis_0_lp_index, sub_axis_0):\n \"\"\"\n inner process of last dim less than one block\n \"\"\"\n\n # move data in\n in_offset = (block_idx * per_core_col_size +\n axis_1_lp_index * max_core_axis_size +\n axis_0_lp_index * max_no_core_axis_size * axis_1) * axis_2\n data_pos_info = (sub_axis_1, sub_axis_0, axis_0, axis_1, axis_2, in_offset)\n _data_move_in_last_dim_lt_one_block(tik_inst, ub_input, data_in, data_pos_info)\n\n # do transpose\n with tik_inst.new_stmt_scope():\n temp_sub_axis_1 = tik_inst.Scalar(\"int64\")\n temp_sub_axis_0 = tik_inst.Scalar(\"int64\")\n data_size_one_block = _get_elment_cnt_one_block(data_in.dtype)\n axis_1_0_2_size = axis_0 * axis_1 * axis_2\n sub_axis_1_0_2_size = sub_axis_1 * sub_axis_0 * axis_2\n\n # to avoid multiple core dirty data\n with tik_inst.if_scope(tik.all(sub_axis_1_0_2_size < data_size_one_block,\n axis_1_0_2_size > data_size_one_block)):\n with tik_inst.if_scope(sub_axis_1 == 1):\n temp_sub_axis_0.set_as(_ceil_div(data_size_one_block, axis_2))\n temp_sub_axis_1.set_as(sub_axis_1)\n with tik_inst.else_scope():\n temp_sub_axis_0.set_as(sub_axis_0)\n temp_sub_axis_1.set_as(_ceil_div(data_size_one_block,\n axis_0 * axis_2))\n with tik_inst.else_scope():\n temp_sub_axis_1.set_as(sub_axis_1)\n temp_sub_axis_0.set_as(sub_axis_0)\n\n sub_dim_size = (temp_sub_axis_1, temp_sub_axis_0, axis_2)\n _transpose_by_2_vnchwconv_not_last_dim(tik_inst, ub_input[ub_offset],\n ub_input, sub_dim_size)\n\n # move data out\n out_offset = ((block_idx * per_core_col_size +\n axis_1_lp_index * max_core_axis_size) * axis_0 +\n axis_0_lp_index * max_no_core_axis_size) * axis_2\n data_pos_info = (sub_axis_1, sub_axis_0, axis_0, axis_1, axis_2, out_offset)\n _data_move_out_last_dim_lt_one_block(tik_inst, data_out, ub_input[ub_offset],\n data_pos_info)\n\n with tik_inst.for_range(0, no_core_loop_cnt) as axis_0_lp_idx:\n _fp32_inner_last_dim_lt_one_block(axis_0_lp_idx, max_no_core_axis_size)\n with tik_inst.if_scope(no_core_left > 0):\n _fp32_inner_last_dim_lt_one_block(no_core_loop_cnt, no_core_left)\n\n with tik_inst.for_range(0, loop_cnt) as axis_1_lp_idx:\n _fp32_mte_process_lt_one_block(axis_1_lp_idx, max_core_axis_size)\n with tik_inst.if_scope(left_data > 0):\n _fp32_mte_process_lt_one_block(loop_cnt, left_data)","def _compute_rwg0_space_data(\n support,\n edge_neighbors,\n edge_neighbors_ptr,\n element_edges,\n number_of_elements,\n number_of_edges,\n include_boundary_dofs,\n truncate_at_segment_edge,\n):\n local2global_map = _np.zeros((number_of_elements, 3), dtype=_np.uint32)\n local_multipliers = _np.zeros((number_of_elements, 3), dtype=_np.float64)\n edge_dofs = -_np.ones(number_of_edges, dtype=_np.int32)\n\n dof_count = 0\n for element in _np.flatnonzero(support):\n has_dof = False\n for local_index in range(3):\n edge_index = element_edges[local_index, element]\n if edge_dofs[edge_index] != -1:\n has_dof = True\n else:\n current_neighbors = edge_neighbors[\n edge_neighbors_ptr[edge_index] : edge_neighbors_ptr[1 + edge_index]\n ]\n supported_neighbors = [e for e in current_neighbors if support[e]]\n if len(supported_neighbors) == 2:\n if edge_dofs[edge_index]:\n edge_dofs[edge_index] = dof_count\n dof_count += 1\n has_dof = True\n if len(supported_neighbors) == 1 and include_boundary_dofs:\n if edge_dofs[edge_index]:\n edge_dofs[edge_index] = dof_count\n dof_count += 1\n has_dof = True\n if not truncate_at_segment_edge:\n for cell in current_neighbors:\n # Add the element to the support\n support[cell] = True\n if not has_dof:\n # If the element has no DOFs, remove it from support\n support[element] = False\n\n for element_index in _np.flatnonzero(support):\n dofmap = -_np.ones(3, dtype=_np.int32)\n for local_index in range(3):\n edge_index = element_edges[local_index, element_index]\n if edge_dofs[edge_index] != -1:\n dofmap[local_index] = edge_dofs[edge_index]\n\n current_neighbors = edge_neighbors[\n edge_neighbors_ptr[edge_index] : edge_neighbors_ptr[1 + edge_index]\n ]\n supported_neighbors = [e for e in current_neighbors if support[e]]\n\n if len(supported_neighbors) == 1:\n local_multipliers[element_index, local_index] = 1\n else:\n # Assign 1 or -1 depending on element index\n local_multipliers[element_index, local_index] = (\n 1 if element_index == min(supported_neighbors) else -1\n )\n\n # For every zero local multiplier assign an existing global dof\n # in this element. This does not change the result as zero multipliers\n # do not contribute. But it allows us not to have to distinguish between\n # existing and non existing dofs later on.\n first_nonzero = 0\n for local_index in range(3):\n if local_multipliers[element_index, local_index] != 0:\n first_nonzero = local_index\n break\n\n for local_index in range(3):\n if local_multipliers[element_index, local_index] == 0:\n dofmap[local_index] = dofmap[first_nonzero]\n local2global_map[element_index, :] = dofmap\n\n return dof_count, support, local2global_map, local_multipliers","def spatial_batchnorm_backward(dout, cache):\n dx, dgamma, dbeta = None, None, None\n\n ###########################################################################\n # TODO: Implement the backward pass for spatial batch normalization. #\n # #\n # HINT: You can implement spatial batch normalization using the vanilla #\n # version of batch normalization defined above. Your implementation should#\n # be very short; ours is less than five lines. #\n ###########################################################################\n s_cache,shape_x = cache\n reshaped_dout = np.reshape(dout,(-1,dout.shape[1]))\n dx_reshaped,dgamma,dbeta = batchnorm_backward_alt(reshaped_dout,s_cache)\n dx = np.reshape(dx_reshaped,shape_x)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n\n return dx, dgamma, dbeta","def pull(self,x,y):\n\t\tself.x_sum -= np.sum(x,axis=0)[:,np.newaxis]\n\t\tself.y_sum -= np.sum(y,axis=0)[:,np.newaxis]\n\t\tself.xy_sum -= np.matmul(np.transpose(x),y)\n\t\tself.xx_sum -= np.matmul(np.transpose(x),x)\n\t\tself.yy_sum -= np.matmul(np.transpose(y),y)\n\t\tself.n -= np.shape(x)[0]","def scatter_array_scatterv_no_cache(self,geoMeta,src_array,ConfigOptions):\n\n\n # Determine which type of input array we have based on the\n # type of numpy array.\n data_type_flag = -1\n if self.rank == 0:\n if src_array.dtype == np.float32:\n data_type_flag = 1\n if src_array.dtype == np.float64:\n data_type_flag = 2\n if src_array.dtype == np.bool:\n data_type_flag = 3\n\n # Broadcast the data_type_flag to other processors\n if self.rank == 0:\n data_type_buffer = np.array([data_type_flag],np.int32)\n else:\n data_type_buffer = np.empty(1,np.int32)\n\n try:\n self.comm.Bcast(data_type_buffer, root=0)\n except:\n ConfigOptions.errMsg = \"Unable to broadcast numpy datatype value from rank 0\"\n err_handler.err_out(ConfigOptions)\n return None\n\n data_type_flag = data_type_buffer[0]\n data_type_buffer = None\n\n # gather buffer offsets and bounds to rank 0\n bounds = np.array(\n [np.int32(geoMeta.x_lower_bound), np.int32(geoMeta.y_lower_bound),\n np.int32(geoMeta.x_upper_bound), np.int32(geoMeta.y_upper_bound)])\n global_bounds = np.zeros((self.size*4),np.int32)\n\n try:\n self.comm.Allgather([bounds, MPI.INTEGER], [global_bounds, MPI.INTEGER])\n except:\n ConfigOptions.errMsg = \"Failed all gathering global bounds at rank\" + str(self.rank)\n err_handler.err_out(ConfigOptions)\n return None\n\n # create slices for x and y bounds arrays\n x_lower = global_bounds[0:(self.size * 4) + 0:4]\n y_lower = global_bounds[1:(self.size * 4) + 1:4]\n x_upper = global_bounds[2:(self.size * 4) + 2:4]\n y_upper = global_bounds[3:(self.size * 4) + 3:4]\n\n # generate counts\n counts = [ (y_upper[i] - y_lower[i]) * (x_upper[i] - x_lower[i])\n for i in range(0,self.size)]\n\n #generate offsets:\n offsets = [0]\n for i in range(0, self.size - 1):\n offsets.append(offsets[i] + counts[i])\n\n # create the send buffer\n if self.rank == 0:\n sendbuf = np.empty([src_array.size],src_array.dtype)\n\n # fill the send buffer\n for i in range(0,self.size):\n start = offsets[i]\n stop = offsets[i]+counts[i]\n sendbuf[start:stop] = src_array[y_lower[i]:y_upper[i],\n x_lower[i]:x_upper[i]].flatten()\n else:\n sendbuf = None\n\n #create the recvbuffer\n if data_type_flag == 1:\n data_type = MPI.FLOAT\n recvbuf=np.empty([counts[self.rank]],np.float32)\n elif data_type_flag == 3: \n data_type = MPI.BOOL\n recvbuf = np.empty([counts[self.rank]], np.bool)\n else:\n data_type = MPI.DOUBLE\n recvbuf = np.empty([counts[self.rank]], np.float64)\n\n #scatter the data\n try:\n self.comm.Scatterv( [sendbuf, counts, offsets, data_type], recvbuf, root=0)\n except:\n ConfigOptions.errMsg = \"Failed Scatterv from rank 0\"\n err_handler.error_out(ConfigOptions)\n return None\n\n subarray = np.reshape(recvbuf,[y_upper[self.rank] -y_lower[self.rank],x_upper[self.rank]- x_lower[self.rank]]).copy()\n return subarray","def _gm_to_ub_one(args):\n tik_instance, data, data_ub, data_offset, ub_offset, ori_nburst, \\\n burst_len, src_stride, dst_stride, cp_align_len = args\n\n if src_stride <= 65535:\n if ori_nburst <= 4095:\n tik_instance.data_move(data_ub[ub_offset],\n data[data_offset],\n 0, ori_nburst,\n burst_len,\n src_stride, dst_stride)\n\n else:\n n_burst = 4095\n c_cycle = ori_nburst // n_burst\n c_mod = ori_nburst % n_burst\n for num_cy in range(c_cycle):\n data_cur = data_offset + (burst_len + src_stride)\\\n * cp_align_len * n_burst * num_cy\n ub_cur = ub_offset + (burst_len + dst_stride)\\\n * cp_align_len * n_burst * num_cy\n tik_instance.data_move(\n data_ub[ub_cur],\n data[data_cur],\n 0, n_burst,\n burst_len,\n src_stride, dst_stride)\n\n if c_mod > 0:\n data_cur = data_offset + (burst_len + src_stride)\\\n * cp_align_len * n_burst * c_cycle\n ub_cur = ub_offset + (burst_len + dst_stride)\\\n * cp_align_len * n_burst * c_cycle\n tik_instance.data_move(\n data_ub[ub_cur],\n data[data_cur],\n 0, c_mod,\n burst_len,\n src_stride, dst_stride)\n\n else:\n for num_nb in range(ori_nburst):\n data_cur = data_offset + (burst_len + src_stride)\\\n * cp_align_len * num_nb\n ub_cur = ub_offset + (burst_len + dst_stride)\\\n * cp_align_len * num_nb\n tik_instance.data_move(\n data_ub[ub_cur],\n data[data_cur],\n 0, 1,\n burst_len,\n 0, 0)","def distort_vxs(self):\n self.dvxs = self.vxs.copy()\n self.dvxs[:, 0] += self.perlin()\n self.dvxs[:, 1] += self.perlin()","def update_E(self):\n self.grid.E[:, 0, :, :] = self.grid.E[:, -1, :, :]","def push_to_mem(self, batch_x, batch_y, t):\n if self.real_epoch > 0:\n return\n\n batch_x = batch_x.cpu()\n batch_y = batch_y.cpu()\n t = t.cpu()\n\n for i in range(batch_x.shape[0]):\n self.age += 1\n if len(self.M) < self.memories:\n self.M.append([batch_x[i], batch_y[i], t])\n else:\n p = np.random.randint(0, self.age)\n if p < self.memories:\n self.M[p] = [batch_x[i], batch_y[i], t]","def move_cloud(self):\n self.remove()\n self.min_x -= 1\n self.max_x -= 1\n self.update()","def update(self, array) -> None:\n this_device = self._current_device_index\n\n # clean up data\n self._array._buffer = {n: None for n in range(num_gpu)}\n self._array._buffer[CPU_INDEX] = None\n\n # copy new data to buffer\n if isinstance(array, numpy.ndarray):\n if this_device != CPU_INDEX: # CPU to GPU\n self._array.set(this_device, cupy.asarray(array))\n else: # data already in CPU\n self._array.set(this_device, array)\n else:\n if this_device == CPU_INDEX: # GPU to CPU\n self._array.set(this_device, cupy.asnumpy(array))\n else: # GPU to GPU\n if int(array.device) == this_device: # data already in this device\n self._array.set(this_device, array)\n else: # GPU to GPU\n dst_data = cupy.empty_like(array)\n dst_data.data.copy_from_device_async(array.data, array.nbytes)\n self._array.set(this_device, dst_data)\n\n # update size\n self.nbytes = array.nbytes\n self.subarray_nbytes = self.nbytes\n\n self._slices = []\n\n # reset coherence\n self._coherence.reset(this_device)\n\n # update shape\n self._array.shape = array.shape\n\n if num_gpu > 0:\n cupy.cuda.stream.get_current_stream().synchronize()","def _move_in_one_more_block():\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx_0:\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx_0],\n src[in_offset + sub_h_idx_0 * w_size],\n 0, 1, sub_w_block, 0, 0)\n # move in one more block of h\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\n tik_inst.data_move(\n dst[sub_w_block * data_cnt_one_block * (sub_h_align_block_size + sub_h_idx_1)],\n src[in_offset + (sub_h_idx_1 + sub_h_size - data_cnt_one_block) * w_size],\n 0, 1, sub_w_block, 0, 0)","def precalculate(self):\n self._sorted = np.argsort(\n self.base[self._array], kind='mergesort') # mergesort for stability\n self._boundaries = util.find_boundaries(\n self.base[self._array][self._sorted])","def test_nvcc_bug():\r\n shape = (5, 4)\r\n aa = theano._asarray(numpy.random.rand(*shape), dtype='float32')\r\n a = aa[::, ::-1]\r\n\r\n b = cuda_ndarray.CudaNdarray(aa)[::, ::-1]\r\n c = copy.copy(b)\r\n d = copy.deepcopy(b)\r\n\r\n assert numpy.allclose(a, numpy.asarray(b))\r\n assert numpy.allclose(a, numpy.asarray(c))\r\n assert numpy.allclose(a, numpy.asarray(d))\r\n b += b\r\n assert numpy.allclose(a+a, numpy.asarray(b))\r\n assert numpy.allclose(a+a, numpy.asarray(c))\r\n assert numpy.allclose(a, numpy.asarray(d))","def global_to_local(npboxes: np.ndarray, window: Box):\n xmin = window.xmin\n ymin = window.ymin\n return npboxes - np.array([[ymin, xmin, ymin, xmin]])","def local_extrema_seuil(sweep, seuil1, seuil2, span) :\n\n #temporary elements\n temp_min = 0\n temp_min_arg = -1\n temp_max = 0\n temp_max_arg = -1\n\n #This holds the result\n up_i = 0\n down_i = 0\n up = array([])\n arg_up = array([])\n down = array([])\n arg_down = array([])\n #init the writing bolean\n min_write = True\n max_write = True\n sweep_size = size(sweep)\n\n for i in range(sweep_size) :\n value = sweep[i]\n #check if we are below the threshold, if yes, next point\n if abs(value) < seuil1 :\n max_write = True\n min_write = True\n if temp_max_arg != -1 :\n #Reshape the array\n s_up = array(shape(up))\n s_up[0] = s_up[0] + 1\n s_up = tuple(s_up)\n up = resize(up,s_up)\n arg_up = resize(arg_up,s_up)\n #Assign values\n up[up_i] = temp_max\n arg_up[up_i] = temp_max_arg\n up_i = up_i + 1\n temp_max = 0\n temp_max_arg = -1\n\n if temp_min_arg != -1 :\n #Reshape the array\n s_down = array(shape(down))\n s_down[0] = s_down[0] + 1\n s_down = tuple(s_down)\n down = resize(down,s_down)\n arg_down = resize(arg_down,s_down)\n #Assign values\n down[down_i] = temp_min\n arg_down[down_i] = temp_min_arg\n down_i = down_i + 1\n temp_min = 0\n temp_min_arg = -1\n\n continue\n\n\n #if we are in beetween the two threshold\n if abs(value) > seuil1 and abs(value) < seuil2 :\n if value < temp_min and min_write :\n temp_min = value\n temp_min_arg = i\n if value > temp_max and max_write:\n temp_max = value\n temp_max_arg = i\n\n #if we are above the threshold\n if abs(value) > seuil2 :\n #Make sure than min and max cannot be accessed before going back below seuil1\n if value < - seuil2 :\n min_write = False\n if(temp_min_arg + span > i) :\n temp_min = 0\n temp_min_arg = -1\n if value > seuil2 :\n max_write = False\n if(temp_max_arg + span > i) :\n temp_max = 0\n temp_max_arg = -1\n\n return [down, arg_down, up, arg_up]","def test_nvcc_bug():\n shape = (5, 4)\n aa = theano._asarray(numpy.random.rand(*shape), dtype='float32')\n a = aa[::, ::-1]\n\n b = cuda_ndarray.CudaNdarray(aa)[::, ::-1]\n c = copy.copy(b)\n d = copy.deepcopy(b)\n\n assert numpy.allclose(a, numpy.asarray(b))\n assert numpy.allclose(a, numpy.asarray(c))\n assert numpy.allclose(a, numpy.asarray(d))\n b += b\n assert numpy.allclose(a+a, numpy.asarray(b))\n assert numpy.allclose(a+a, numpy.asarray(c))\n assert numpy.allclose(a, numpy.asarray(d))","def update_E(self):\n self.grid.E[0, :, :, :] = self.grid.E[-1, :, :, :]","def preprocess(self):\n\n mm_magcoord.add_aacgm_coordinates(self)\n mm_magcoord.add_quasi_dipole_coordinates(self)\n mm_sc.calculate_ecef_velocity(self)\n mm_sc.add_ram_pointing_sc_attitude_vectors(self)\n\n return","def _data_move_out_no_transpose(tik_inst, dst, src, data_pos_info):\n data_size, out_offset, h_size, w_size = data_pos_info\n data_one_block = _get_elment_cnt_one_block(src.dtype)\n data_align_block = data_size // data_one_block\n is_data_block_algin = data_size % data_one_block == 0\n is_all_data_small_one_block = h_size * w_size < data_one_block\n\n with tik_inst.if_scope(is_data_block_algin):\n tik_inst.data_move(dst[out_offset], src, 0, 1, data_align_block, 0, 0)\n with tik_inst.else_scope():\n with tik_inst.if_scope(is_all_data_small_one_block):\n tik_inst.data_move(dst[out_offset], src, 0, 1, 1, 0, 0)\n with tik_inst.else_scope():\n tik_inst.data_move(dst[out_offset], src, 0, 1, data_align_block, 0, 0)\n tik_inst.data_move(dst[out_offset + data_size - data_one_block],\n src[data_align_block * data_one_block],\n 0, 1, 1, 0, 0)","def _setup_ndarrays(self) -> None:\n empty = self.ele_orig * 0\n # 2D arrays\n self.ele = np.copy(self.ele_orig) # Elevation including glaciers\n self.slp = np.copy(empty) # Slope with glacier geometry\n self.asp = np.copy(empty) # Classified aspect with glacier geometry\n self.h = np.copy(empty) # Local glacier height\n self.u = np.copy(empty) # Local glacier velocity\n self.hs = hillshade(\n self.ele_orig,\n self.PLOT_HILLSHADE_AZIMUTH,\n self.PLOT_HILLSHADE_ALTITUDE,\n ) # HS\n\n # Initialize array store\n self.store = ArrayStore()\n self.store.create(\"h\", self.MODEL_RECORD_SIZE)\n self.store.create(\"u\", self.MODEL_RECORD_SIZE)","def c_not_align_split_n_fp32(self, tik_instance):\n n_d, d_d, h_d, w_d, c_d = self.dst_shape\n dhw_d = d_d * h_d * w_d\n nc_one = self.ub_ele // dhw_d\n n_ub = nc_one // 2 // self.cp_align_len // c_d\n\n all_core = _ceil_div(n_d, n_ub)\n ac_num = _set_core_num(all_core)\n\n with tik_instance.for_range(0, ac_num, block_num=ac_num) as num_core:\n ub_ori = tik_instance.Tensor(\"float16\",\n (self.ub_ele * 2,),\n name=\"ub_ori\",\n scope=tik.scope_ubuf)\n ub_trans = tik_instance.Tensor(\"float16\",\n (self.ub_ele * 2,),\n name=\"ub_trans\",\n scope=tik.scope_ubuf)\n ub_tail = tik_instance.Tensor(\"float16\",\n (16,),\n name=\"ub_tail\",\n scope=tik.scope_ubuf)\n\n ub_loop = _set_loop(tik_instance, num_core, ac_num, all_core)\n\n with tik_instance.for_range(0, ub_loop) as num_u:\n core_index = num_u * ac_num + num_core\n\n with tik_instance.if_scope(core_index < all_core - 1):\n n_len = n_ub\n n_before = n_ub * core_index\n args = tik_instance, ub_ori, ub_trans, ub_tail, \\\n n_before, n_len\n self.func_c_not_align_split_n_fp32(args)\n\n with tik_instance.else_scope():\n n_before = (all_core - 1) * n_ub\n n_len = n_d - n_before\n args = tik_instance, ub_ori, ub_trans, ub_tail, \\\n n_before, n_len\n self.func_c_not_align_split_n_fp32(args)\n\n return tik_instance","def backtransform_target(self, data):\n # print(data)\n # print(self.target_max)\n #data = FloatTensor(data)\n data *= self.target_max\n data += self.target_min\n return data # .numpy()","def setupGPUStandard(solver):\n #Correct GPU block\n solver.gpuBlock = (slice(0,solver.sharedShape[0],1),)+solver.gpuBlock\n solver.gpuReadBlock = solver.gpuBlock[:2]+tuple([slice(cs.start-solver.operating,cs.stop+solver.operating,1) for cs in solver.gpuBlock[2:]])\n blockShape =[element.stop-element.start for element in solver.gpuBlock]\n blockShape[-1] += int(2*solver.operating) #Adding 2 blocks in the column direction\n blockShape[-2] += int(2*solver.operating) #Adding 2 blocks in the column direction\n #Creating local GPU array with split\n grid = (int((blockShape[2]-2*solver.operating)/solver.blocksize[0]),int((blockShape[3]-2*solver.operating)/solver.blocksize[1])) #Grid size\n #Creating constants\n bsp = lambda x: int(numpy.prod(blockShape[x:])) #block shape product returned as an integer\n const_dict = ({\"NV\":blockShape[1],'SX':blockShape[2],'SY':blockShape[3],\"VARS\":bsp(2),\"TIMES\":bsp(1),\"OPS\":solver.operating,\"ITS\":solver.intermediate})\n solver.GPUArray = mallocGPUArray(blockShape)\n solver.localGPUArray = numpy.zeros(blockShape)\n #Building CUDA source code\n solver.gpu = io.buildGPUSource(solver.gpu)\n io.copyConstants(solver.gpu,const_dict) #This copys gpu constants not global constants\n solver.cpu.set_globals(*solver.globals,source_mod=solver.gpu)\n #Make GPU geometry\n solver.standard.initializeGPU(solver.gpu.get_function(\"Standard\"),solver.blocksize,grid)","def test_op_sub_offload_array_float(self):\n\n device = pymic.devices[0]\n stream = device.get_default_stream()\n a = numpy.arange(1.0, 4711.0 * 1024, dtype=float)\n o = a + 1.0\n\n old_a = numpy.empty_like(a)\n old_o = numpy.empty_like(o)\n old_a[:] = a[:]\n old_o[:] = o[:]\n expect = a - o\n\n offl_a = stream.bind(a)\n offl_o = stream.bind(o)\n offl_r = offl_a - offl_o\n offl_a.update_host()\n r = offl_r.update_host().array\n stream.sync()\n\n self.assertEqual(r.shape, a.shape)\n self.assertEqual(r.dtype, a.dtype)\n self.assertTrue((a == old_a).all(),\n \"Input array operand 1 must not be modified: \"\n \"{0} should be {1}\".format(a, old_a))\n self.assertTrue((o == old_o).all(),\n \"Input array operand 2 must not be modified: \"\n \"{0} should be {1}\".format(o, old_o))\n self.assertTrue((r == expect).all(),\n \"Array contains unexpected values: \"\n \"{0} should be {1}\".format(r, expect))","def update_E(self):\n self.grid.E[:, :, 0, :] = self.grid.E[:, :, -1, :]","def place_targets():\n\n \n coords = []\n while len(coords)<self.N_targets:\n x = np.random.randint(self.BORDER_MARGIN,self.map_dimensions[1]+1-self.BORDER_MARGIN,size=1)[0]\n y = np.random.randint(self.BORDER_MARGIN,self.map_dimensions[0]+1-self.BORDER_MARGIN,size=1)[0]\n p = (x,y)\n all_valid = True\n for rect in self.coordinates__obstacles:\n if not check_valid_placement(p,rect):\n all_valid = False\n break\n if all_valid:\n coords +=[p]\n self.coordinates__targets = coords","def move(self):\n \"\"\" Responsible for transformations \"\"\"\n pos, com, success = self.perception \n if self.destination is None:\n return array([0,0])\n\n if not self.awake:\n return array([0,0])\n\n\n if self.phase == 4 and self.proper_formation is not None:\n no_go = []\n for i in range(0,len(self.proper_formation)):\n if i != self.order and self.proper_formation[i][0] == self.proper_formation[self.order][0]:\n no_go.append(self.transform(self.proper_formation[i][1] - self.position))\n pos = merge_array_lists(pos, no_go)\n\n if self.phase == 2:\n point = self.destination.copy() - self.position\n elif self.phase > 2:\n point = self.transform(self.destination.copy() - self.position)\n else:\n point = self.destination.copy()\n\n if not array_equal(point, array([0,0])):\n reachable, path = findpathtoclosest(array([0,0]), point, pos)\n \n if len(path) == 0:\n move = array([0,0]) \n else:\n move = path[0]\n if not reachable and not array_equal(move,array([0,0])):\n if self.phase == 2:\n self.closest_i_could_get = path[-1] + self.position\n elif self.phase > 2:\n self.closest_i_could_get = self.transform2(path[-1]) + self.position\n else:\n self.closest_i_could_get = path[-1]\n elif not reachable:\n if self.phase > 1:\n self.closest_i_could_get = self.position\n else:\n self.closest_i_could_get = array([0,0])\n else:\n self.closest_i_could_get = None\n\n if reachable and self.phase == 4 and array_equal(move,array([0,0])):\n move = self.randomStep()\n self.closest_i_could_get = None\n\n else:\n move = array([0,0])\n self.closest_i_could_get = None\n\n return move"],"string":"[\n \"def _data_move_out_last_dim_lt_one_block(tik_inst, dst, src, data_pos_info):\\n sub_axis_1, sub_axis_0, axis_0, axis_1, axis_2, out_offset = data_pos_info\\n data_size_one_block = _get_elment_cnt_one_block(src.dtype)\\n\\n with tik_inst.if_scope(sub_axis_1 == 1):\\n with tik_inst.if_scope(sub_axis_0 * axis_2 > data_size_one_block):\\n sub_axis_0_2 = sub_axis_0 * axis_2\\n sub_axis_0_block_align = sub_axis_0_2 // data_size_one_block\\n left_data = sub_axis_0_2 % data_size_one_block\\n tik_inst.data_move(dst[out_offset], src, 0, 1, sub_axis_0_block_align, 0, 0)\\n with tik_inst.if_scope(left_data > 0):\\n with tik_inst.new_stmt_scope():\\n reg_temp = [tik_inst.Scalar(src.dtype)\\n for i in ADDR_IDX_LIST[:data_size_one_block]]\\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\\n reg_temp[idx].set_as(src[sub_axis_0_2 - data_size_one_block + idx])\\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\\n src[idx].set_as(reg_temp[idx])\\n tik_inst.data_move(dst[out_offset + sub_axis_0_2 - data_size_one_block],\\n src, 0, 1, 1, 0, 0)\\n with tik_inst.else_scope():\\n # for case sub_axis_0 * axis_2 < data_size_one_block\\n with tik_inst.if_scope(axis_0 * axis_1 * axis_2 > data_size_one_block):\\n m_sub_axis_0 = _ceil_div(data_size_one_block, axis_2)\\n sub_axis_0_2 = m_sub_axis_0 * axis_2\\n sub_axis_0_block_align = sub_axis_0_2 // data_size_one_block\\n left_data = sub_axis_0_2 % data_size_one_block\\n tik_inst.data_move(dst[out_offset + (sub_axis_0 - m_sub_axis_0) * axis_2],\\n src, 0, 1, sub_axis_0_block_align, 0, 0)\\n with tik_inst.if_scope(left_data > 0):\\n with tik_inst.new_stmt_scope():\\n reg_temp = [tik_inst.Scalar(src.dtype)\\n for i in ADDR_IDX_LIST[:data_size_one_block]]\\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\\n reg_temp[idx].set_as(src[sub_axis_0_2 - data_size_one_block + idx])\\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\\n src[idx].set_as(reg_temp[idx])\\n tik_inst.data_move(dst[out_offset + sub_axis_0 * axis_2 -\\n data_size_one_block],\\n src, 0, 1, 1, 0, 0)\\n with tik_inst.else_scope():\\n # the shape size is not bigger than one block size\\n tik_inst.data_move(dst[out_offset], src, 0, 1,\\n _ceil_div(axis_0 * axis_1 * axis_2, data_size_one_block), 0, 0)\\n\\n with tik_inst.else_scope():\\n with tik_inst.if_scope(sub_axis_1 * axis_0 * axis_2 > data_size_one_block):\\n sub_axis_1_0_2 = sub_axis_1 * axis_0 * axis_2\\n sub_axis_1_0_2_block_align = sub_axis_1_0_2 // data_size_one_block\\n left_data = sub_axis_1_0_2 % data_size_one_block\\n tik_inst.data_move(dst[out_offset], src, 0, 1, sub_axis_1_0_2_block_align, 0, 0)\\n with tik_inst.if_scope(left_data > 0):\\n with tik_inst.new_stmt_scope():\\n reg_temp = [tik_inst.Scalar(src.dtype)\\n for i in ADDR_IDX_LIST[:data_size_one_block]]\\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\\n reg_temp[idx].set_as(src[sub_axis_1_0_2 - data_size_one_block + idx])\\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\\n src[idx].set_as(reg_temp[idx])\\n tik_inst.data_move(dst[out_offset + sub_axis_1_0_2 - data_size_one_block],\\n src, 0, 1, 1, 0, 0)\\n with tik_inst.else_scope():\\n # to make sure move in data size is not less than one block\\n with tik_inst.if_scope(axis_0 * axis_1 * axis_2 > data_size_one_block):\\n m_sub_axis_1 = _ceil_div(data_size_one_block, axis_0 * axis_2)\\n sub_axis_1_0_2 = m_sub_axis_1 * axis_0 * axis_2\\n sub_axis_0_block_align = sub_axis_1_0_2 // data_size_one_block\\n left_data = sub_axis_1_0_2 % data_size_one_block\\n tik_inst.data_move(dst[out_offset + (sub_axis_1 - m_sub_axis_1) * axis_0 * axis_2],\\n src, 0, 1, sub_axis_0_block_align, 0, 0)\\n with tik_inst.if_scope(left_data > 0):\\n with tik_inst.new_stmt_scope():\\n reg_temp = [tik_inst.Scalar(src.dtype)\\n for i in ADDR_IDX_LIST[:data_size_one_block]]\\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\\n reg_temp[idx].set_as(src[sub_axis_1_0_2 - data_size_one_block + idx])\\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\\n src[idx].set_as(reg_temp[idx])\\n tik_inst.data_move(dst[out_offset + sub_axis_1 * axis_0 * axis_2 -\\n data_size_one_block],\\n src, 0, 1, 1, 0, 0)\\n with tik_inst.else_scope():\\n # the shape size is not bigger than one block size\\n tik_inst.data_move(dst[out_offset], src, 0, 1,\\n _ceil_div(axis_0 * axis_1 * axis_2, data_size_one_block), 0, 0)\",\n \"def allocate_arrays(self):\\n self.prng_state = np.random.get_state()\\n # Generate arrays of random shape\\n self.shape1 = np.random.randint(20, high=512, size=(2,))\\n self.shape2 = np.random.randint(20, high=512, size=(2,))\\n self.array1 = np.random.rand(*self.shape1).astype(np.float32)\\n self.array2 = np.random.rand(*self.shape2).astype(np.float32)\\n self.d_array1 = parray.to_device(self.queue, self.array1)\\n self.d_array2 = parray.to_device(self.queue, self.array2)\\n # Generate random offsets\\n offset1_y = np.random.randint(2, high=min(self.shape1[0], self.shape2[0]) - 10)\\n offset1_x = np.random.randint(2, high=min(self.shape1[1], self.shape2[1]) - 10)\\n offset2_y = np.random.randint(2, high=min(self.shape1[0], self.shape2[0]) - 10)\\n offset2_x = np.random.randint(2, high=min(self.shape1[1], self.shape2[1]) - 10)\\n self.offset1 = (offset1_y, offset1_x)\\n self.offset2 = (offset2_y, offset2_x)\\n # Compute the size of the rectangle to transfer\\n size_y = np.random.randint(2, high=min(self.shape1[0], self.shape2[0]) - max(offset1_y, offset2_y) + 1)\\n size_x = np.random.randint(2, high=min(self.shape1[1], self.shape2[1]) - max(offset1_x, offset2_x) + 1)\\n self.transfer_shape = (size_y, size_x)\",\n \"def _move_in_one_more_block():\\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx:\\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx],\\n src[w_offset + w_size * sub_h_idx], 0, 1, sub_w_block, 0, 0)\\n # in order to avoid dirty data when multiple core\\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block *\\n (sub_h_align_block_size + sub_h_idx_1)],\\n src[w_offset +\\n w_size * (sub_h_size - data_cnt_one_block + sub_h_idx_1)],\\n 0, 1, sub_w_block, 0, 0)\",\n \"def trim2DArray(input_arr, threshold=0): \\n\\n print(input_arr.shape)\\n ul_x, ul_y = calculateTrimOffsetForward(input_arr, threshold)\\n lr_x, lr_y = calculateTrimOffsetBackward(input_arr, threshold)\\n\\n output_arr = input_arr[ul_y:lr_y, ul_x:lr_x]\\n\\n print(output_arr.shape)\\n\\n return (output_arr)\",\n \"def _data_move_in_last_dim_lt_one_block(tik_inst, dst, src, data_pos_info):\\n sub_axis_1, sub_axis_0, axis_0, axis_1, axis_2, in_offset = data_pos_info\\n data_size_one_block = _get_elment_cnt_one_block(src.dtype)\\n\\n with tik_inst.if_scope(sub_axis_1 == 1):\\n with tik_inst.if_scope(tik.any(sub_axis_0 * axis_2 >= data_size_one_block,\\n axis_0 * axis_1 * axis_2 <= data_size_one_block)):\\n with tik_inst.for_range(0, sub_axis_0) as sub_axis_0_idx:\\n tik_inst.data_move(\\n dst[sub_axis_0_idx * data_size_one_block],\\n src[sub_axis_0_idx * axis_1 * axis_2 + in_offset],\\n 0, 1, 1, 0, 0)\\n with tik_inst.else_scope():\\n # to make sure move in data size is not less than one block\\n m_sub_axis_0 = _ceil_div(data_size_one_block, axis_2)\\n with tik_inst.for_range(0, m_sub_axis_0) as m_sub_axis_0_idx:\\n tik_inst.data_move(\\n dst[m_sub_axis_0_idx * data_size_one_block],\\n src[(m_sub_axis_0_idx + sub_axis_0 - m_sub_axis_0) * axis_1 * axis_2 +\\n in_offset],\\n 0, 1, 1, 0, 0)\\n\\n with tik_inst.else_scope():\\n with tik_inst.if_scope(tik.any(sub_axis_1 * axis_0 * axis_2 >= data_size_one_block,\\n axis_0 * axis_1 * axis_2 <= data_size_one_block)):\\n with tik_inst.for_range(0, sub_axis_1) as sub_axis_1_idx:\\n with tik_inst.for_range(0, sub_axis_0) as sub_axis_0_idx:\\n tik_inst.data_move(\\n dst[(sub_axis_0_idx + sub_axis_1_idx * sub_axis_0) * data_size_one_block],\\n src[(sub_axis_0_idx * axis_1 + sub_axis_1_idx) * axis_2 + in_offset],\\n 0, 1, 1, 0, 0)\\n with tik_inst.else_scope():\\n # to make sure move in data size is not less than one block\\n m_sub_axis_1 = _ceil_div(data_size_one_block, axis_0 * axis_2)\\n with tik_inst.for_range(0, m_sub_axis_1) as m_sub_axis_1_idx:\\n with tik_inst.for_range(0, sub_axis_0) as sub_axis_0_idx:\\n tik_inst.data_move(\\n dst[(sub_axis_0_idx + m_sub_axis_1_idx * sub_axis_0) *\\n data_size_one_block],\\n src[(sub_axis_0_idx * axis_1 + sub_axis_1 - m_sub_axis_1 +\\n m_sub_axis_1_idx) * axis_2 + in_offset],\\n 0, 1, 1, 0, 0)\",\n \"def _data_move_out_last_dim_be_one_block(tik_inst, dst, src, data_pos_info):\\n\\n sub_h_size, sub_w_size, c_size, h_size, w_size, out_offset = data_pos_info\\n data_size_one_block = _get_elment_cnt_one_block(src.dtype)\\n is_w_block_align = w_size % data_size_one_block == 0\\n sub_w_block = sub_w_size // data_size_one_block\\n sub_w_left = sub_w_size % data_size_one_block\\n cw_block = c_size * w_size // data_size_one_block\\n stride_len = cw_block - sub_w_block\\n\\n with tik_inst.if_scope(is_w_block_align):\\n with tik_inst.if_scope(tik.any(stride_len > MTE_STRIDES, sub_h_size > REPEAT_LIMIT_MTE)):\\n with tik_inst.for_range(0, sub_h_size) as sub_h_idx:\\n tik_inst.data_move(dst[sub_h_idx * c_size * w_size + out_offset],\\n src[sub_h_idx * sub_w_size],\\n 0, 1, sub_w_block, 0, 0)\\n with tik_inst.else_scope():\\n tik_inst.data_move(dst[out_offset], src, 0, sub_h_size, sub_w_block, 0, stride_len)\\n\\n with tik_inst.else_scope():\\n # suppose w_size > data_size_one_block\\n with tik_inst.for_range(0, sub_h_size) as sub_h_idx:\\n with tik_inst.if_scope(sub_w_block > 0):\\n tik_inst.data_move(dst[sub_h_idx * c_size * w_size + out_offset],\\n src[sub_h_idx * (sub_w_block + 1) * data_size_one_block],\\n 0, 1, sub_w_block, 0, 0)\\n with tik_inst.if_scope(sub_w_left > 0):\\n tik_inst.data_move(dst[sub_h_idx * c_size * w_size + out_offset +\\n sub_w_size - data_size_one_block],\\n src[(sub_h_idx * (sub_w_block + 1) + sub_w_block) *\\n data_size_one_block],\\n 0, 1, 1, 0, 0)\",\n \"def cleanup(self):\\n self.subpixel, self.pixel = self.stepup(self.subpixel, self.pixel, AxisDistance.pixelsize)\\n self.pixel, self.tile = self.stepup(self.pixel, self.tile, AxisDistance.tilesize)\",\n \"def update(self):\\n for i in range(self.min_y, self.max_y + 1):\\n for j in range(self.min_x, self.max_x + 1):\\n try:\\n DIMENSIONAL_ARRAY[i-1][j-1] = self.lis[i-self.min_y][j-self.min_x]\\n except IndexError:\\n pass\",\n \"def optimizeFluidArray(self):\\n print(\\\"Run the function for optimization.\\\")\\n self.fluidNodes = np.empty(self.voidSpace, dtype = np.int64)\\n ySize = self.ny; xSize = self.nx\\n print(\\\"Start to fill effective fluid nodes.\\\")\\n tmpIndicesDomain = -np.ones(self.isDomain.shape, dtype = np.int64)\\n tmpIndicesFN = 0\\n for i in sp.arange(ySize):\\n for j in sp.arange(xSize):\\n if (self.isDomain[i, j] == 1):\\n# if (self.effectiveDomain[i, j] == 255.):\\n tmpIndices = i * xSize + j\\n self.fluidNodes[tmpIndicesFN] = tmpIndices\\n tmpIndicesDomain[i, j] = tmpIndicesFN\\n tmpIndicesFN += 1\\n self.neighboringNodes = np.zeros(self.fluidNodes.size * 8, dtype = np.int64)\\n if self.interactionType == \\\"'EFS'\\\":\\n if self.explicitScheme == 8:\\n self.neighboringNodesISO8 = np.zeros(self.fluidNodes.size * 24, \\\\\\n dtype = np.int64)\\n elif self.explicitScheme == 10:\\n self.neighboringNodesISO10 = np.zeros(self.fluidNodes.size * 36, \\\\\\n dtype = np.int64)\\n totalNodes = self.fluidNodes.size\\n #use cuda to generate the array for neighboring nodes\\n print(\\\"Start to fill neighboring nodes\\\")\\n deviceFluidNodes = cuda.to_device(self.fluidNodes)\\n devicetmpIndicesDomain = cuda.to_device(tmpIndicesDomain)\\n# deviceIsDomain = cuda.to_device(self.isDomain)\\n deviceNeighboringNodes = cuda.to_device(self.neighboringNodes)\\n blockNumX = int(self.xDimension / self.threadNum) \\n blockNumY = math.ceil(self.fluidNodes.size / self.xDimension)\\n threadPerBlock1D = (self.threadNum, 1)\\n grid = (blockNumX, blockNumY)\\n\\n fillNeighboringNodes[grid, threadPerBlock1D](totalNodes, self.nx, self.ny, \\\\\\n self.xDimension, deviceFluidNodes, devicetmpIndicesDomain, \\\\\\n deviceNeighboringNodes)\\n self.neighboringNodes = deviceNeighboringNodes.copy_to_host()\\n if self.interactionType == \\\"'EFS'\\\":\\n if self.explicitScheme == 8:\\n deviceNeighboringNodesISO8 = cuda.to_device(self.neighboringNodesISO8)\\n fillNeighboringNodesISO8[grid, threadPerBlock1D](totalNodes, self.nx, self.ny, \\\\\\n self.xDimension, deviceFluidNodes, devicetmpIndicesDomain, \\\\\\n deviceNeighboringNodesISO8)\\n self.neighboringNodesISO8 = deviceNeighboringNodesISO8.copy_to_host()\\n elif self.explicitScheme == 10:\\n deviceNeighboringNodesISO10 = cuda.to_device(self.neighboringNodesISO10)\\n fillNeighboringNodesISO10[grid, threadPerBlock1D](totalNodes, self.nx, self.ny, \\\\\\n self.xDimension, deviceFluidNodes, devicetmpIndicesDomain, \\\\\\n deviceNeighboringNodesISO10)\\n self.neighboringNodesISO10 = deviceNeighboringNodesISO10.copy_to_host()\\n \\n print(\\\"Redefine the fluid nodes.\\\")\\n# cuda.current_context().trashing.clear()\\n self.optFluidPDF = np.empty([self.typesFluids, self.fluidNodes.size, 9])\\n self.optFluidRho = np.empty([self.typesFluids, self.fluidNodes.size])\\n self.optMacroVelocity = np.zeros(self.fluidNodes.size)\\n self.optMacroVelocityX = np.zeros(self.fluidNodes.size, dtype = np.float64)\\n self.optMacroVelocityY = np.zeros(self.fluidNodes.size, dtype = np.float64)\\n self.optForceX = np.zeros([self.typesFluids, self.fluidNodes.size], \\\\\\n dtype = np.float64)\\n self.optForceY = np.zeros([self.typesFluids, self.fluidNodes.size], \\\\\\n dtype = np.float64)\\n tmpDomain = np.array([i == 1 for i in self.isDomain.reshape(ySize * xSize)])\\n for i in sp.arange(self.typesFluids):\\n self.optFluidRho[i] = self.fluidsDensity.reshape(self.typesFluids, \\\\\\n ySize * xSize)[i, tmpDomain]\\n self.optFluidPDF[i] = self.fluidPDF.reshape(self.typesFluids, ySize * \\\\\\n xSize, 9)[i, tmpDomain]\",\n \"def setupGPUSwept(solver):\\n solver.gpuBlock = (slice(0,solver.sharedShape[0],1),)+solver.gpuBlock\\n getGPUReadBlockSwept(solver) #Finish creating gpuReadBlock here\\n blockShape =[element.stop for element in solver.gpuBlock]\\n blockShape[-1] += int(2*solver.blocksize[0]) #Adding 2 blocks in the column direction\\n # Creating local GPU array with split\\n grid = (int((blockShape[2])/solver.blocksize[0]),int((blockShape[3])/solver.blocksize[1])) #Grid size\\n #Creating constants\\n bsp = lambda x: int(numpy.prod(blockShape[x:])) #block shape product returned as an integer\\n const_dict = ({\\\"NV\\\":blockShape[1],'SX':blockShape[2],'SY':blockShape[3],\\\"VARS\\\":bsp(2),\\\"TIMES\\\":bsp(1),\\\"MPSS\\\":solver.maxPyramidSize,\\\"MOSS\\\":solver.maxOctSize,\\\"OPS\\\":solver.operating,\\\"ITS\\\":solver.intermediate})\\n solver.GPUArray = mallocGPUArray(blockShape) #Allocated GPU\\n solver.localGPUArray = numpy.zeros(blockShape)\\n #Building CUDA source code\\n solver.gpu = io.buildGPUSource(solver.gpu)\\n io.copyConstants(solver.gpu,const_dict) #This copys cpu constants not global constants\\n solver.cpu.set_globals(*solver.globals,source_mod=solver.gpu)\\n # Make GPU geometry\\n solver.Up.initializeGPU(solver.gpu.get_function(\\\"UpPyramid\\\"),solver.blocksize,(grid[0],grid[1]-1))\\n solver.Oct.initializeGPU(solver.gpu.get_function(\\\"Octahedron\\\"),solver.blocksize,(grid[0],grid[1]-1))\\n solver.Down.initializeGPU(solver.gpu.get_function(\\\"DownPyramid\\\"),solver.blocksize,(grid[0],grid[1]-1))\\n solver.Yb.initializeGPU(solver.gpu.get_function(\\\"YBridge\\\"),solver.blocksize,grid)\\n solver.Xb.initializeGPU(solver.gpu.get_function(\\\"XBridge\\\"),solver.blocksize,grid)\",\n \"def _data_move_in_last_dim_be_one_block(tik_inst, dst, src, data_pos_info):\\n\\n sub_h_size, sub_w_size, h_size, w_size, in_offset = data_pos_info\\n data_size_one_block = _get_elment_cnt_one_block(src.dtype)\\n is_w_block_align = w_size % data_size_one_block == 0\\n sub_w_block = sub_w_size // data_size_one_block\\n sub_w_left = sub_w_size % data_size_one_block\\n w_block = w_size // data_size_one_block\\n stride_len = w_block - sub_w_block\\n\\n with tik_inst.if_scope(is_w_block_align):\\n with tik_inst.if_scope(tik.any(stride_len > MTE_STRIDES, sub_h_size > REPEAT_LIMIT_MTE)):\\n with tik_inst.for_range(0, sub_h_size) as sub_h_idx:\\n tik_inst.data_move(dst[sub_h_idx * sub_w_size],\\n src[sub_h_idx * w_size + in_offset],\\n 0, 1, sub_w_block, 0, 0)\\n with tik_inst.else_scope():\\n with tik_inst.if_scope(stride_len > 0):\\n tik_inst.data_move(dst, src[in_offset], 0, sub_h_size, sub_w_block, stride_len, 0)\\n with tik_inst.else_scope():\\n tik_inst.data_move(dst, src[in_offset], 0, 1, sub_h_size * sub_w_block, 0, 0)\\n\\n with tik_inst.else_scope():\\n # suppose w_size > data_size_one_block\\n with tik_inst.for_range(0, sub_h_size) as sub_h_idx:\\n with tik_inst.if_scope(sub_w_block > 0):\\n tik_inst.data_move(dst[sub_h_idx * (sub_w_block + 1) * data_size_one_block],\\n src[sub_h_idx * w_size + in_offset],\\n 0, 1, sub_w_block, 0, 0)\\n with tik_inst.if_scope(sub_w_left > 0):\\n tik_inst.data_move(dst[(sub_h_idx * (sub_w_block + 1) + sub_w_block) *\\n data_size_one_block],\\n src[sub_h_idx * w_size + in_offset + sub_w_size -\\n data_size_one_block],\\n 0, 1, 1, 0, 0)\",\n \"def test_cpy2d(self):\\n # Reference\\n o1 = self.offset1\\n o2 = self.offset2\\n T = self.transfer_shape\\n logger.info(\\\"\\\"\\\"Testing D->D rectangular copy with (N1_y, N1_x) = %s,\\n (N2_y, N2_x) = %s:\\n array2[%d:%d, %d:%d] = array1[%d:%d, %d:%d]\\\"\\\"\\\" %\\n (\\n str(self.shape1), str(self.shape2),\\n o2[0], o2[0] + T[0],\\n o2[1], o2[1] + T[1],\\n o1[0], o1[0] + T[0],\\n o1[1], o1[1] + T[1]\\n )\\n )\\n self.array2[o2[0]:o2[0] + T[0], o2[1]:o2[1] + T[1]] = self.array1[o1[0]:o1[0] + T[0], o1[1]:o1[1] + T[1]]\\n kernel_args = (\\n self.d_array2.data,\\n self.d_array1.data,\\n np.int32(self.shape2[1]),\\n np.int32(self.shape1[1]),\\n np.int32(self.offset2[::-1]),\\n np.int32(self.offset1[::-1]),\\n np.int32(self.transfer_shape[::-1])\\n )\\n wg = None\\n ndrange = self.transfer_shape[::-1]\\n self.program.cpy2d(self.queue, ndrange, wg, *kernel_args)\\n res = self.d_array2.get()\\n self.compare(res, self.array2)\",\n \"def __copy2array(self):\\n # extract gradient and bias\\n w = self.init_layer.weight\\n b = self.init_layer.bias\\n self.params = [[w,b]] # save it to buffer\\n if self.bpoints is not None:\\n for d, x1 in zip(self.deltas, self.bpoints):\\n y1 = w *x1 + b # find the endpoint of line segment (x1, y1)\\n w = w + d # add on the delta to gradient\\n b = y1 - w * x1 # find new bias of line segment\\n self.params.append([w,b]) # add to buffer\\n\\n # create buffer\\n self.wb = torch.zeros(len(self.params), len(self.params[0]))\\n for i in range(self.wb.shape[0]):\\n for j in range(self.wb.shape[1]):\\n self.wb[i,j] = self.params[i][j]\",\n \"def updateArrays(self):\\n for channelNumber in range(0, 8):\\n self.channels[channelNumber][self.currentPosition]=self._voltage_get(channelNumber)#update next element in each array\\n self.currentPosition+=1\\n if self.currentPosition>=self.numberOfPoints:#reset position to beginning when we hit max number of points (like rolling oscilloscope)\\n self.currentPosition=0\\n self.cursorXS = self.getCurrentPositionArray()\\n #could also set the next points to NaN's to make a gap!\",\n \"def batch_split(self) -> np.array:\\n pass\",\n \"def _data_move_out_mc_on_w(tik_inst, dst, src, data_pos_info):\\n\\n # sub_h_size is the original value without any change\\n sub_h_size, sub_w_size, h_size, w_size, out_offset = data_pos_info\\n data_size_one_block = _get_elment_cnt_one_block(src.dtype)\\n\\n def _sub_h_not_block_align_bigger_one_block():\\n \\\"\\\"\\\"\\n sub_h_size is not block align, sub_h_size is bigger than one block\\n \\\"\\\"\\\"\\n\\n sub_h_block = sub_h_size // data_size_one_block\\n with tik_inst.for_range(0, sub_w_size) as sub_w_idx_2:\\n with tik_inst.if_scope(sub_h_block > 0):\\n tik_inst.data_move(\\n dst[out_offset + sub_w_idx_2 * h_size],\\n src[sub_w_idx_2 * (sub_h_block + 1) * data_size_one_block],\\n 0, 1, sub_h_block, 0, 0)\\n # move in one more block for this case\\n tik_inst.data_move(\\n dst[out_offset + sub_w_idx_2 * h_size + sub_h_size - data_size_one_block],\\n src[sub_w_idx_2 * (sub_h_block + 1) * data_size_one_block +\\n sub_h_block * data_size_one_block],\\n 0, 1, 1, 0, 0)\\n\\n with tik_inst.if_scope(sub_h_size == h_size):\\n # the data order in ub is the expected order\\n sub_hw_size = sub_h_size * sub_w_size\\n with tik_inst.if_scope(h_size % data_size_one_block == 0):\\n tik_inst.data_move(dst[out_offset],\\n src,\\n 0, 1, sub_hw_size // data_size_one_block, 0, 0)\\n with tik_inst.else_scope():\\n # sub_h_size is smaller than one block\\n with tik_inst.if_scope(h_size < data_size_one_block):\\n # the data_move will move 1 block at least\\n with tik_inst.if_scope(sub_hw_size < data_size_one_block):\\n tik_inst.data_move(dst[out_offset],\\n src,\\n 0, 1, 1, 0, 0)\\n with tik_inst.else_scope():\\n sub_hw_block = sub_hw_size // data_size_one_block\\n tik_inst.data_move(dst[out_offset],\\n src,\\n 0, 1, sub_hw_block, 0, 0)\\n # in order to avoid dirty data\\n with tik_inst.new_stmt_scope():\\n temp_reg = [tik_inst.Scalar(src.dtype)\\n for i in ADDR_IDX_LIST[:data_size_one_block]]\\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\\n temp_reg[idx].set_as(src[sub_hw_size - data_size_one_block + idx])\\n for idx in ADDR_IDX_LIST[:data_size_one_block]:\\n src[idx].set_as(temp_reg[idx])\\n tik_inst.data_move(dst[out_offset + sub_hw_size - data_size_one_block],\\n src, 0, 1, 1, 0, 0)\\n with tik_inst.else_scope():\\n # sub_h_size is not block align, sub_h_size is bigger than one block\\n _sub_h_not_block_align_bigger_one_block()\\n\\n with tik_inst.else_scope():\\n # h_size > sub_h_size, h_size is block align\\n stride_cnt = (h_size - sub_h_size) // data_size_one_block\\n with tik_inst.if_scope(tik.all(h_size % data_size_one_block == 0,\\n stride_cnt <= MTE_STRIDES)):\\n tik_inst.data_move(dst[out_offset],\\n src,\\n 0, sub_w_size, sub_h_size // data_size_one_block, 0, stride_cnt)\\n with tik_inst.else_scope():\\n # h_size is not block align, sub_h_size is block align\\n with tik_inst.if_scope(sub_h_size % data_size_one_block == 0):\\n with tik_inst.for_range(0, sub_w_size) as sub_w_idx:\\n tik_inst.data_move(dst[out_offset + sub_w_idx * h_size],\\n src[sub_w_idx * sub_h_size],\\n 0, 1, sub_h_size // data_size_one_block, 0, 0)\\n with tik_inst.else_scope():\\n _sub_h_not_block_align_bigger_one_block()\",\n \"def _compute_bc_space_data(\\n grid, bary_grid, coarse_space, truncate_at_segment_edge, swapped_normals\\n):\\n from bempp.api.grid.grid import enumerate_vertex_adjacent_elements\\n from scipy.sparse import coo_matrix\\n\\n coarse_support = _np.zeros(grid.entity_count(0), dtype=_np.bool_)\\n coarse_support[coarse_space.support_elements] = True\\n\\n if not truncate_at_segment_edge:\\n for global_dof_index in range(coarse_space.global_dof_count):\\n local_dofs = coarse_space.global2local[global_dof_index]\\n edge_index = grid.data().element_edges[local_dofs[0][1], local_dofs[0][0]]\\n for v in range(2):\\n vertex = grid.data().edges[v, edge_index]\\n start = grid.vertex_neighbors.indexptr[vertex]\\n end = grid.vertex_neighbors.indexptr[vertex + 1]\\n for cell in grid.vertex_neighbors.indices[start:end]:\\n coarse_support[cell] = True\\n\\n coarse_support_elements = _np.array([i for i, j in enumerate(coarse_support) if j])\\n number_of_support_elements = len(coarse_support_elements)\\n\\n bary_support_elements = 6 * _np.repeat(coarse_support_elements, 6) + _np.tile(\\n _np.arange(6), number_of_support_elements\\n )\\n\\n support = _np.zeros(bary_grid.number_of_elements, dtype=_np.bool_)\\n support[bary_support_elements] = True\\n\\n bary_support_size = len(bary_support_elements)\\n\\n bary_vertex_to_edge = enumerate_vertex_adjacent_elements(\\n bary_grid, bary_support_elements, swapped_normals\\n )\\n\\n edge_vectors = (\\n bary_grid.vertices[:, bary_grid.edges[0, :]]\\n - bary_grid.vertices[:, bary_grid.edges[1, :]]\\n )\\n\\n edge_lengths = _np.linalg.norm(edge_vectors, axis=0)\\n\\n normal_multipliers = _np.repeat(coarse_space.normal_multipliers, 6)\\n local2global = _np.zeros((bary_grid.number_of_elements, 3), dtype=\\\"uint32\\\")\\n local_multipliers = _np.zeros((bary_grid.number_of_elements, 3), dtype=\\\"uint32\\\")\\n\\n local2global[support] = _np.arange(3 * bary_support_size).reshape(\\n bary_support_size, 3\\n )\\n\\n local_multipliers[support] = 1\\n\\n coarse_dofs = []\\n bary_dofs = []\\n values = []\\n\\n for global_dof_index in range(coarse_space.global_dof_count):\\n local_dofs = coarse_space.global2local[global_dof_index]\\n edge_index = grid.data().element_edges[local_dofs[0][1], local_dofs[0][0]]\\n neighbors = grid.edge_neighbors[edge_index]\\n other = neighbors[1] if local_dofs[0][0] == neighbors[0] else neighbors[0]\\n if coarse_space.local_multipliers[local_dofs[0][0], local_dofs[0][1]] > 0:\\n lower = local_dofs[0][0]\\n upper = other\\n else:\\n lower = other\\n upper = local_dofs[0][0]\\n vertex1, vertex2 = grid.data().edges[:, edge_index]\\n # Re-order the vertices so that they appear in anti-clockwise\\n # order.\\n for local_index, vertex_index in enumerate(grid.data().elements[:, upper]):\\n if vertex_index == vertex1:\\n break\\n if vertex2 == grid.data().elements[(local_index - 1) % 3, upper]:\\n vertex1, vertex2 = vertex2, vertex1\\n\\n # Get the local indices of vertex1 and vertex2 in upper and lower\\n local_vertex1 = -1\\n for index, value in enumerate(grid.data().elements[:, upper]):\\n if value == vertex1:\\n local_vertex1 = index\\n break\\n else:\\n local_vertex1 = -1\\n\\n for index, value in enumerate(grid.data().elements[:, lower]):\\n if value == vertex2:\\n local_vertex2 = index\\n break\\n else:\\n local_vertex2 = -1\\n\\n for vertex_index, bary_element, sign in [\\n (vertex1, 6 * upper + 2 * local_vertex1, -1.0),\\n (vertex2, 6 * lower + 2 * local_vertex2, 1.0),\\n ]:\\n # Find the reference element index in elements adjacent to that vertex\\n for ind, elem in enumerate(bary_vertex_to_edge[vertex_index]):\\n if bary_element == elem[0]:\\n break\\n\\n # Now get all the relevant edges starting to count above\\n # ind\\n num_bary_elements = len(bary_vertex_to_edge[vertex_index])\\n vertex_edges = []\\n for index in range(num_bary_elements):\\n elem_edge_pair = bary_vertex_to_edge[vertex_index][\\n (index + ind) % num_bary_elements\\n ]\\n for n in range(1, 3):\\n vertex_edges.append((elem_edge_pair[0], elem_edge_pair[n]))\\n\\n # We do not want the reference edge part of this list\\n vertex_edges.pop(0)\\n vertex_edges.pop(-1)\\n\\n # We now have a list of edges associated with the vertex counting from edge\\n # after the reference edge onwards in anti-clockwise order. We can now\\n # assign the coefficients\\n\\n nc = num_bary_elements // 2 # Number of elements on coarse grid\\n # adjacent to vertex.\\n\\n count = 0\\n for index, edge in enumerate(vertex_edges):\\n if index % 2 == 0:\\n count += 1\\n elem_index, local_edge_index = edge[:]\\n edge_length = edge_lengths[\\n bary_grid.data().element_edges[local_edge_index, elem_index]\\n ]\\n bary_dofs.append(local2global[elem_index, local_edge_index])\\n coarse_dofs.append(global_dof_index)\\n values.append(sign * (nc - count) / (2 * nc * edge_length))\\n sign *= -1\\n\\n # Now process the tangential rwgs close to the reference edge\\n\\n # Get the associated barycentric elements and fill the coefficients in\\n # the matrix.\\n\\n bary_upper_minus = 6 * upper + 2 * local_vertex1\\n bary_upper_plus = 6 * upper + 2 * local_vertex1 + 1\\n bary_lower_minus = 6 * lower + 2 * local_vertex2\\n bary_lower_plus = 6 * lower + 2 * local_vertex2 + 1\\n\\n # The edge that we need always has local edge index 2.\\n # Can compute the edge length now.\\n\\n edge_length_upper = edge_lengths[\\n bary_grid.data().element_edges[2, bary_upper_minus]\\n ]\\n edge_length_lower = edge_lengths[\\n bary_grid.data().element_edges[2, bary_lower_minus]\\n ]\\n\\n # Now assign the dofs in the arrays\\n coarse_dofs.append(global_dof_index)\\n coarse_dofs.append(global_dof_index)\\n coarse_dofs.append(global_dof_index)\\n coarse_dofs.append(global_dof_index)\\n\\n bary_dofs.append(local2global[bary_upper_minus, 2])\\n bary_dofs.append(local2global[bary_upper_plus, 2])\\n bary_dofs.append(local2global[bary_lower_minus, 2])\\n bary_dofs.append(local2global[bary_lower_plus, 2])\\n\\n values.append(1.0 / (2 * edge_length_upper))\\n values.append(-1.0 / (2 * edge_length_upper))\\n values.append(-1.0 / (2 * edge_length_lower))\\n values.append(1.0 / (2 * edge_length_lower))\\n\\n nentries = len(coarse_dofs)\\n np_coarse_dofs = _np.zeros(nentries, dtype=_np.uint32)\\n np_bary_dofs = _np.zeros(nentries, dtype=_np.uint32)\\n np_values = _np.zeros(nentries, dtype=_np.float64)\\n\\n np_coarse_dofs[:] = coarse_dofs\\n np_bary_dofs[:] = bary_dofs\\n np_values[:] = values\\n\\n dof_transformation = coo_matrix(\\n (np_values, (np_bary_dofs, np_coarse_dofs)),\\n shape=(3 * bary_support_size, coarse_space.global_dof_count),\\n dtype=_np.float64,\\n ).tocsr()\\n\\n return (\\n dof_transformation,\\n support,\\n normal_multipliers,\\n local2global,\\n local_multipliers,\\n )\",\n \"def _move_to_original_bounds(new_space: Hypercuboid, original_space: Hypercuboid) -> Hypercuboid:\\n moved_bounds: Hypercuboid = []\\n\\n for new_interval, old_interval in zip(new_space, original_space):\\n moved_bounds.append(shift_to_within_parameter_bounds(new_interval=new_interval, old_interval=old_interval))\\n\\n return moved_bounds\",\n \"def boat_array_reduction(mesh, boat, **kwargs):\\n # boat = d['boat']\\n # print(d['mesh'])\\n # mesh = d['mesh']\\n boat_new = boat[0::10, 0::2]\\n mesh_new = [mesh[i][0::10, 0::2] for i in range(2)]\\n # print('reduction', boat_new.shape, mesh_new[0].shape, mesh_new[1].shape)\\n return mesh_new, boat_new\",\n \"def backward(ctx, gradPixels, dpointIdxMap, gradRhoMap, gradWsMap, gradIsBehind):\\n pointIdxMap, bbPositionMap, isBehind, WsMap, rhoMap, depthMap, Ws, rhoValues, projPoints, cameraPoints, boundingBoxes, pixels, Ms = ctx.saved_tensors\\n mergeThreshold = ctx.mergeThreshold\\n focalLength = ctx.focalLength\\n numPoint = ctx.numPoint\\n considerZ = ctx.considerZ\\n bbWidth = ctx.bbWidth\\n bbHeight = ctx.bbHeight\\n batchSize, height, width, topK, C = WsMap.shape\\n if ctx.needs_input_grad[0]: # rho will not be backpropagated\\n WsMap_ = torch.where(isBehind.unsqueeze(-1), torch.zeros(1, 1, 1, 1, 1, device=WsMap.device, dtype=WsMap.dtype), WsMap)\\n totalIdxMap = pointIdxMap*bbHeight*bbWidth+bbPositionMap[:, :, :, :, 0]*bbWidth+bbPositionMap[:, :, :, :, 1]\\n # TODO check dNormalizeddRho\\n rhoMap_filtered = torch.where(isBehind, torch.zeros(1, 1, 1, 1, device=rhoMap.device, dtype=rhoMap.dtype), rhoMap)\\n sumRho = torch.sum(rhoMap_filtered, dim=-1, keepdim=True)\\n dNormalizeddRho = torch.where(rhoMap > 0, 1/sumRho-rhoMap/sumRho, rhoMap)\\n dRho = _guided_scatter_maps(numPoint*bbWidth*bbHeight, dNormalizeddRho.unsqueeze(-1)*gradPixels.unsqueeze(3)*WsMap_, totalIdxMap, boundingBoxes)\\n dRho = torch.sum(dRho, dim=-1)\\n dRho = torch.reshape(dRho, (batchSize, numPoint, bbHeight, bbWidth))\\n else:\\n dRho = None\\n\\n if ctx.needs_input_grad[2]:\\n # dPixels/dWs = Rho\\n rhoMap_filtered = torch.where(isBehind, torch.zeros(1, 1, 1, 1, device=rhoMap.device, dtype=rhoMap.dtype), rhoMap)\\n sumRho = torch.sum(rhoMap_filtered, dim=-1, keepdim=True)\\n sumRho = torch.where(sumRho == 0, torch.zeros_like(sumRho), sumRho)\\n rhoMap_normalized = rhoMap_filtered/sumRho\\n # BxHxWx3 -> BxHxWxKx3 -> BxNx3\\n dWs = _guided_scatter_maps(numPoint, gradPixels.unsqueeze(3)*rhoMap_normalized.unsqueeze(-1), pointIdxMap, boundingBoxes)\\n else:\\n dWs = None\\n\\n if ctx.needs_input_grad[3]:\\n localWidth = ctx.localWidth\\n localHeight = ctx.localHeight\\n depthValues = cameraPoints[:, :, 2].contiguous()\\n # B,N,1\\n dIdp = torch.zeros_like(projPoints, device=gradPixels.device, dtype=gradPixels.dtype)\\n dIdz = torch.zeros(1, numPoint, device=gradPixels.device, dtype=gradPixels.dtype)\\n gamma = 0.1\\n # rhoMap_filtered = torch.where(isBehind, torch.zeros(1, 1, 1, 1, device=rhoMap.device, dtype=rhoMap.dtype), rhoMap)\\n # sumRho = torch.sum(rhoMap_filtered, dim=-1, keepdim=True)\\n # rhoMap_normalized = rhoMap_filtered/sumRho\\n # rhoMap_normalized = rhoMap_filtered/sumRho\\n outputs = _visibility_reference_backward(focalLength, mergeThreshold, gamma, considerZ, localHeight, localWidth, 0,\\n gradPixels, pointIdxMap, rhoMap, WsMap, depthMap, isBehind,\\n pixels, boundingBoxes, projPoints, Ws, depthValues, rhoValues, Ms, dIdp, dIdz)\\n dIdp, dIdz, debugTensor = outputs\\n dIdcam = torch.zeros_like(cameraPoints)\\n dIdcam[:, :, 2] = dIdz\\n # saved_variables[\\\"dI\\\"] = gradPixels.detach().cpu()\\n # saved_variables[\\\"dIdp\\\"] = saved_variables[\\\"dIdp\\\"].scatter_(1, saved_variables[\\\"renderable_idx\\\"].expand(-1, -1, dIdp.shape[-1]),\\n # dIdp.cpu().detach())\\n # saved_variables[\\\"projPoints\\\"] = saved_variables[\\\"projPoints\\\"].scatter_(1, saved_variables[\\\"renderable_idx\\\"].expand(-1,-1,dIdp.shape[-1]),\\n # projPoints.cpu().detach())\\n # saved_variables[\\\"dIdpMap\\\"] = debugTensor[:,:,:,:2].cpu().detach()\\n else:\\n dIdp = dIdcam = None\\n\\n return (None, None, dWs, dIdp, None, None, dIdcam, None, None, None, None, None, None, None, None, None, None)\",\n \"def backward(ctx, gradPixels, dpointIdxMap, gradRhoMap, gradWsMap, gradIsBehind):\\n pointIdxMap, bbPositionMap, isBehind, WsMap, rhoMap, depthMap, Ws, rhoValues, projPoints, cameraPoints, boundingBoxes, pixels, Ms = ctx.saved_tensors\\n mergeThreshold = ctx.mergeThreshold\\n focalLength = ctx.focalLength\\n numPoint = ctx.numPoint\\n considerZ = ctx.considerZ\\n bbWidth = ctx.bbWidth\\n bbHeight = ctx.bbHeight\\n batchSize, height, width, topK, C = WsMap.shape\\n if ctx.needs_input_grad[0]: # rho will not be backpropagated\\n WsMap_ = torch.where(isBehind.unsqueeze(-1), torch.zeros(1, 1, 1, 1, 1, device=WsMap.device, dtype=WsMap.dtype), WsMap)\\n totalIdxMap = pointIdxMap*bbHeight*bbWidth+bbPositionMap[:, :, :, :, 0]*bbWidth+bbPositionMap[:, :, :, :, 1]\\n # TODO check dNormalizeddRho\\n rhoMap_filtered = torch.where(isBehind, torch.zeros(1, 1, 1, 1, device=rhoMap.device, dtype=rhoMap.dtype), rhoMap)\\n sumRho = torch.sum(rhoMap_filtered, dim=-1, keepdim=True)\\n dNormalizeddRho = torch.where(rhoMap > 0, 1/sumRho-rhoMap/sumRho, rhoMap)\\n dRho = _guided_scatter_maps(numPoint*bbWidth*bbHeight, dNormalizeddRho.unsqueeze(-1)*gradPixels.unsqueeze(3)*WsMap_, totalIdxMap, boundingBoxes)\\n dRho = torch.sum(dRho, dim=-1)\\n dRho = torch.reshape(dRho, (batchSize, numPoint, bbHeight, bbWidth))\\n else:\\n dRho = None\\n\\n if ctx.needs_input_grad[2]:\\n # dPixels/dWs = Rho\\n rhoMap_filtered = torch.where(isBehind, torch.zeros(1, 1, 1, 1, device=rhoMap.device, dtype=rhoMap.dtype), rhoMap)\\n sumRho = torch.sum(rhoMap_filtered, dim=-1, keepdim=True)\\n sumRho = torch.where(sumRho == 0, torch.zeros_like(sumRho), sumRho)\\n rhoMap_normalized = rhoMap_filtered/sumRho\\n # BxHxWx3 -> BxHxWxKx3 -> BxNx3\\n dWs = _guided_scatter_maps(numPoint, gradPixels.unsqueeze(3)*rhoMap_normalized.unsqueeze(-1), pointIdxMap, boundingBoxes)\\n else:\\n dWs = None\\n\\n if ctx.needs_input_grad[3]:\\n localWidth = ctx.localWidth\\n localHeight = ctx.localHeight\\n depthValues = cameraPoints[:, :, 2].contiguous()\\n # B,N,1\\n dIdp = torch.zeros_like(projPoints, device=gradPixels.device, dtype=gradPixels.dtype)\\n dIdz = torch.zeros(1, numPoint, device=gradPixels.device, dtype=gradPixels.dtype)\\n outputs = _visibility_backward(focalLength, mergeThreshold, considerZ,\\n localHeight, localWidth,\\n gradPixels, pointIdxMap, rhoMap, WsMap, depthMap, isBehind,\\n pixels, boundingBoxes, projPoints, Ws, depthValues, rhoValues, dIdp, dIdz)\\n dIdp, dIdz = outputs\\n # outputs = _visibility_debug_backward(mergeThreshold, focalLength, considerZ,\\n # localHeight, localWidth, 0,\\n # gradPixels, pointIdxMap, rhoMap, WsMap, depthMap, isBehind,\\n # pixels, boundingBoxes, projPoints, Ws, depthValues, rhoValues, dIdp, dIdz)\\n # dIdp, dIdz, debugTensor = outputs\\n\\n dIdcam = torch.zeros_like(cameraPoints)\\n dIdcam[:, :, 2] = dIdz\\n # saved_variables[\\\"dI\\\"] = gradPixels.detach().cpu()\\n # saved_variables[\\\"dIdp\\\"] = saved_variables[\\\"dIdp\\\"].scatter_(1, saved_variables[\\\"renderable_idx\\\"].expand(-1, -1, dIdp.shape[-1]),\\n # dIdp.cpu().detach())\\n # saved_variables[\\\"projPoints\\\"] = saved_variables[\\\"projPoints\\\"].scatter_(1, saved_variables[\\\"renderable_idx\\\"].expand(-1,-1,dIdp.shape[-1]),\\n # projPoints.cpu().detach())\\n # saved_variables[\\\"dIdpMap\\\"] = debugTensor[:,:,:,:2].cpu().detach()\\n else:\\n dIdp = dIdcam = None\\n\\n return (None, None, dWs, dIdp, None, None, dIdcam, None, None, None, None, None, None, None, None, None, None)\",\n \"def offset_to_uvd(self, x):\\n self.batch_size = x.shape[0]\\n self.W = x.shape[2]\\n self.H = x.shape[3] \\n self.D = 5\\n self.grid_size = self.W*self.H*self.D\\n \\n grid_linear = x.reshape(self.batch_size, 64, -1)\\n\\n index = torch.from_numpy(np.asarray(np.unravel_index(np.arange(self.grid_size), \\n (self.W, self.H, self.D)))).type(torch.FloatTensor)\\n u = index[0, :].unsqueeze(0).expand(21, -1)\\n v = index[1, :].unsqueeze(0).expand(21, -1)\\n z = index[2, :].unsqueeze(0).expand(21, -1)\\n\\n if self.device != \\\"cpu\\\":\\n u = u.cuda()\\n v = v.cuda()\\n z = z.cuda()\\n\\n pred_uvd_no_offset = grid_linear[:, :63, :].reshape(self.batch_size, 21, 3, self.grid_size)\\n pred_conf = grid_linear[:, 63, :].reshape(self.batch_size, self.W, self.H, self.D)\\n pred_conf = torch.sigmoid(pred_conf)\\n \\n # middle finger root is hand root\\n pred_uvd_no_offset[:, self.hand_root, :, :] = torch.sigmoid(pred_uvd_no_offset[:, self.hand_root, :, :])\\n \\n pred_uvd = pred_uvd_no_offset.clone().detach()\\n pred_uvd[:, :, 0, :] = (pred_uvd[:, :, 0, :] + u) / self.W\\n pred_uvd[:, :, 1, :] = (pred_uvd[:, :, 1, :] + v) / self.H\\n pred_uvd[:, :, 2, :] = (pred_uvd[:, :, 2, :] + z) / self.D\\n \\n pred_uvd_no_offset = pred_uvd_no_offset.reshape(self.batch_size, 21, 3, self.W, self.H, self.D)\\n \\n return pred_uvd_no_offset, pred_uvd, pred_conf\",\n \"def forward_mbr(self, eouts, elens, ys_ref, recog_params, idx2token):\\n bs, xmax, xdim = eouts.size()\\n nbest = recog_params.get('recog_beam_width')\\n assert nbest >= 2\\n assert idx2token is not None\\n scaling_factor = 1.0\\n training = self.training\\n self.eval()\\n with torch.no_grad():\\n nbest_hyps_id, _, scores = self.beam_search(eouts, elens, params=recog_params, nbest=nbest, exclude_eos=True)\\n exp_wer = 0\\n nbest_hyps_id_batch = []\\n grad_list = []\\n for b in range(bs):\\n nbest_hyps_id_b = [np.fromiter(y, dtype=np.int64) for y in nbest_hyps_id[b]]\\n nbest_hyps_id_batch += nbest_hyps_id_b\\n scores_b = np2tensor(np.array(scores[b], dtype=np.float32), eouts.device)\\n probs_b_norm = torch.softmax(scaling_factor * scores_b, dim=-1)\\n wers_b = np2tensor(np.array([(compute_wer(ref=idx2token(ys_ref[b]).split(' '), hyp=idx2token(nbest_hyps_id_b[n]).split(' '))[0] / 100) for n in range(nbest)], dtype=np.float32), eouts.device)\\n exp_wer_b = (probs_b_norm * wers_b).sum()\\n grad_list += [(probs_b_norm * (wers_b - exp_wer_b)).sum()]\\n exp_wer += exp_wer_b\\n exp_wer /= bs\\n if training:\\n self.train()\\n eouts_expand = eouts.unsqueeze(1).expand(-1, nbest, -1, -1).contiguous().view(bs * nbest, xmax, xdim)\\n elens_expand = elens.unsqueeze(1).expand(-1, nbest).contiguous().view(bs * nbest)\\n ys_in, ys_out, ylens = append_sos_eos(nbest_hyps_id_batch, self.eos, self.eos, self.pad, eouts.device)\\n dstates = self.zero_state(bs * nbest)\\n cv = eouts.new_zeros(bs * nbest, 1, self.enc_n_units)\\n self.score.reset()\\n aw = None\\n lmout, lmstate = None, None\\n ys_emb = self.embed_token_id(ys_in)\\n src_mask = make_pad_mask(elens_expand).unsqueeze(1)\\n logits = []\\n for i in range(ys_in.size(1)):\\n if self.lm is not None:\\n lmout, lmstate, _ = self.lm.predict(ys_in[:, i:i + 1], lmstate)\\n dstates, cv, aw, attn_state, attn_v = self.decode_step(eouts_expand, dstates, cv, ys_emb[:, i:i + 1], src_mask, aw, lmout, mode='parallel')\\n logits.append(attn_v)\\n if self.attn_type in ['gmm', 'sagmm']:\\n aw = attn_state['myu']\\n logits = self.output(torch.cat(logits, dim=1))\\n log_probs = torch.log_softmax(logits, dim=-1)\\n eos = ys_in.new_zeros((1,)).fill_(self.eos)\\n nbest_hyps_id_batch_pad = pad_list([torch.cat([np2tensor(y, eouts.device), eos], dim=0) for y in nbest_hyps_id_batch], self.pad)\\n grad = eouts.new_zeros(bs * nbest, nbest_hyps_id_batch_pad.size(1), self.vocab)\\n for b in range(bs):\\n onehot = torch.eye(self.vocab)[nbest_hyps_id_batch_pad[b * nbest:(b + 1) * nbest]]\\n grad[b * nbest:(b + 1) * nbest] = grad_list[b] * onehot\\n grad = grad.masked_fill_((nbest_hyps_id_batch_pad == self.pad).unsqueeze(2), 0)\\n loss_mbr = self.mbr(log_probs, nbest_hyps_id_batch_pad, exp_wer, grad)\\n loss_ce = torch.zeros((1,), dtype=torch.float32, device=eouts.device)\\n if self.mbr_ce_weight > 0:\\n loss_ce = self.forward_att(eouts, elens, ys_ref)[0]\\n loss_ce = loss_ce.unsqueeze(0)\\n return loss_mbr, loss_ce\",\n \"def update(self):\\n self._g, self._B = self._constraint_assembler.preallocate_g_and_B(self._no_of_dofs_unconstrained,\\n self._dofidxs(),\\n self._no_of_constraints_by_object())\",\n \"def _fp32_inner_last_dim_lt_one_block(axis_0_lp_index, sub_axis_0):\\n\\n # move data in\\n in_offset = (block_idx * per_core_col_size +\\n axis_1_lp_index * max_core_axis_size +\\n axis_0_lp_index * max_no_core_axis_size * axis_1) * axis_2\\n data_pos_info = (sub_axis_1, sub_axis_0, axis_0, axis_1, axis_2, in_offset)\\n _data_move_in_last_dim_lt_one_block(tik_inst, ub_input, data_in, data_pos_info)\\n\\n # do transpose\\n with tik_inst.new_stmt_scope():\\n temp_sub_axis_1 = tik_inst.Scalar(\\\"int64\\\")\\n temp_sub_axis_0 = tik_inst.Scalar(\\\"int64\\\")\\n data_size_one_block = _get_elment_cnt_one_block(data_in.dtype)\\n axis_1_0_2_size = axis_0 * axis_1 * axis_2\\n sub_axis_1_0_2_size = sub_axis_1 * sub_axis_0 * axis_2\\n\\n # to avoid multiple core dirty data\\n with tik_inst.if_scope(tik.all(sub_axis_1_0_2_size < data_size_one_block,\\n axis_1_0_2_size > data_size_one_block)):\\n with tik_inst.if_scope(sub_axis_1 == 1):\\n temp_sub_axis_0.set_as(_ceil_div(data_size_one_block, axis_2))\\n temp_sub_axis_1.set_as(sub_axis_1)\\n with tik_inst.else_scope():\\n temp_sub_axis_0.set_as(sub_axis_0)\\n temp_sub_axis_1.set_as(_ceil_div(data_size_one_block,\\n axis_0 * axis_2))\\n with tik_inst.else_scope():\\n temp_sub_axis_1.set_as(sub_axis_1)\\n temp_sub_axis_0.set_as(sub_axis_0)\\n\\n sub_dim_size = (temp_sub_axis_1, temp_sub_axis_0, axis_2)\\n _transpose_by_2_vnchwconv_not_last_dim(tik_inst, ub_input[ub_offset],\\n ub_input, sub_dim_size)\\n\\n # move data out\\n out_offset = ((block_idx * per_core_col_size +\\n axis_1_lp_index * max_core_axis_size) * axis_0 +\\n axis_0_lp_index * max_no_core_axis_size) * axis_2\\n data_pos_info = (sub_axis_1, sub_axis_0, axis_0, axis_1, axis_2, out_offset)\\n _data_move_out_last_dim_lt_one_block(tik_inst, data_out, ub_input[ub_offset],\\n data_pos_info)\",\n \"def move_grids(self, fld, comm, time):\\n # To avoid discrepancies between processors, only the first proc\\n # decides whether to send the data, and broadcasts the information.\\n dz = comm.dz\\n if comm.rank==0:\\n # Move the continuous position of the moving window object\\n self.zmin += self.v * (time - self.t_last_move)\\n # Find the number of cells by which the window should move\\n zmin_global_domain, zmax_global_domain = comm.get_zmin_zmax(\\n local=False, with_damp=False, with_guard=False )\\n n_move = int( (self.zmin - zmin_global_domain)/dz )\\n else:\\n n_move = None\\n # Broadcast the information to all proc\\n if comm.size > 1:\\n n_move = comm.mpi_comm.bcast( n_move )\\n\\n # Move the grids\\n if n_move != 0:\\n # Move the global domain\\n comm.shift_global_domain_positions( n_move*dz )\\n # Shift the fields\\n Nm = len(fld.interp)\\n for m in range(Nm):\\n # Modify the values of the corresponding z's\\n fld.interp[m].zmin += n_move*fld.interp[m].dz\\n fld.interp[m].zmax += n_move*fld.interp[m].dz\\n # Shift/move fields by n_move cells in spectral space\\n self.shift_spect_grid( fld.spect[m], n_move )\\n\\n # Because the grids have just been shifted, there is a shift\\n # in the cell indices that are used for the prefix sum.\\n if fld.use_cuda:\\n fld.prefix_sum_shift += n_move\\n # This quantity is reset to 0 whenever prefix_sum is recalculated\\n\\n # Prepare the positions of injection for the particles\\n # (The actual creation of particles is done when the routine\\n # exchange_particles of boundary_communicator.py is called)\\n if comm.rank == comm.size-1:\\n # Move the injection position\\n self.z_inject += self.v * (time - self.t_last_move)\\n # Take into account the motion of the end of the plasma\\n self.z_end_plasma += self.v_end_plasma * (time - self.t_last_move)\\n # Increment the number of particle cells to add\\n nz_new = int( (self.z_inject - self.z_end_plasma)/dz )\\n self.nz_inject += nz_new\\n # Increment the virtual position of the end of the plasma\\n # (When `generate_particles` is called, then the plasma\\n # is injected between z_end_plasma - nz_inject*dz and z_end_plasma,\\n # and afterwards nz_inject is set to 0.)\\n self.z_end_plasma += nz_new*dz\\n\\n # Change the time of the last move\\n self.t_last_move = time\",\n \"def __init__process(self, n_cpu):\\n global shared_slices\\n global shared_data\\n\\n shared_slices_base = sharedctypes.RawArray(ctypes.c_double,\\n self._projection.shape[0])\\n shared_slices = np.frombuffer(shared_slices_base)\\n shared_slices = shared_slices.reshape((len(self._q.R), -1))\\n\\n shared_grad_base = sharedctypes.RawArray(ctypes.c_double,\\n self._projection.shape[0])\\n shared_grad = np.frombuffer(shared_grad_base)\\n shared_grad = shared_grad.reshape((len(self._q.R), -1))\\n\\n shared_data_base = mp.Array(ctypes.c_double,\\n self._data.size,\\n lock=False)\\n shared_data = np.ctypeslib.as_array(shared_data_base)\\n shared_data = shared_data.reshape(self._data.shape)\\n shared_data[:] = self._data\\n\\n self._pool = mp.Pool(n_cpu)\",\n \"def move_and_process_input(batch):\\n x, y = batch\\n x = x.to(device).float()\\n y = torch.as_tensor(y).to(device)\\n x = x.permute(0, -1, 1, 2, 3)\\n return x, y\",\n \"def _overlap_crop_forward(self, x, shave=10, min_size=100000, bic=None):\\n n_GPUs = 1\\n scale = self.config['dataset']['scale']\\n b, c, h, w = x.size()\\n h_half, w_half = h // 2, w // 2\\n h_size, w_size = h_half + shave, w_half + shave\\n lr_list = [\\n x[:, :, 0:h_size, 0:w_size],\\n x[:, :, 0:h_size, (w - w_size):w],\\n x[:, :, (h - h_size):h, 0:w_size],\\n x[:, :, (h - h_size):h, (w - w_size):w]]\\n\\n if bic is not None:\\n bic_h_size = h_size*scale\\n bic_w_size = w_size*scale\\n bic_h = h*scale\\n bic_w = w*scale\\n \\n bic_list = [\\n bic[:, :, 0:bic_h_size, 0:bic_w_size],\\n bic[:, :, 0:bic_h_size, (bic_w - bic_w_size):bic_w],\\n bic[:, :, (bic_h - bic_h_size):bic_h, 0:bic_w_size],\\n bic[:, :, (bic_h - bic_h_size):bic_h, (bic_w - bic_w_size):bic_w]]\\n\\n if w_size * h_size < min_size:\\n sr_list = []\\n for i in range(0, 4, n_GPUs):\\n lr_batch = torch.cat(lr_list[i:(i + n_GPUs)], dim=0)\\n if bic is not None:\\n bic_batch = torch.cat(bic_list[i:(i + n_GPUs)], dim=0)\\n\\n sr_batch_temp = self.netG(lr_batch)\\n\\n if isinstance(sr_batch_temp, list):\\n sr_batch = sr_batch_temp[-1]\\n else:\\n sr_batch = sr_batch_temp\\n\\n sr_list.extend(sr_batch.chunk(n_GPUs, dim=0))\\n else:\\n sr_list = [\\n self._overlap_crop_forward(patch, shave=shave, min_size=min_size) \\\\\\n for patch in lr_list\\n ]\\n\\n h, w = scale * h, scale * w\\n h_half, w_half = scale * h_half, scale * w_half\\n h_size, w_size = scale * h_size, scale * w_size\\n shave *= scale\\n\\n output = x.new(b, c, h, w)\\n output[:, :, 0:h_half, 0:w_half] \\\\\\n = sr_list[0][:, :, 0:h_half, 0:w_half]\\n output[:, :, 0:h_half, w_half:w] \\\\\\n = sr_list[1][:, :, 0:h_half, (w_size - w + w_half):w_size]\\n output[:, :, h_half:h, 0:w_half] \\\\\\n = sr_list[2][:, :, (h_size - h + h_half):h_size, 0:w_half]\\n output[:, :, h_half:h, w_half:w] \\\\\\n = sr_list[3][:, :, (h_size - h + h_half):h_size, (w_size - w + w_half):w_size]\\n\\n return output\",\n \"def _update(self):\\n self.parametrize_beam()\\n self.update_ranks()\\n self._points = tf.reshape(self._endpoint, (1, 2)) * tf.reshape(self._ranks, (-1, 1))\",\n \"def reshape(self, bottom, top):\\n\\t\\tpass\",\n \"def recenter(obs, bot_norm):\\n recentered = []\\n for i in range(obs.shape[0]): ## iterate through envs\\n one_obs = obs[i]\\n piece = np.transpose(one_obs[:][57:57+4][:], (1,0,2))\\n bg = np.zeros((64*2, 64, 3), dtype=np.uint8)\\n diff_min = 100\\n loc_min = -1\\n for loc in range(64-3):\\n block = piece[loc:loc+3]\\n block = np.transpose(block, (1,0,2))\\n diff = abs(np.sum(bot_norm - block/np.linalg.norm(block)))\\n if diff < diff_min:\\n diff_min = diff\\n loc_min = loc\\n blk = piece[loc_min:loc_min+3]\\n #print(\\\"detected loc: \\\", loc_min)\\n center = 62 - loc_min\\n bg[center:center+64] = one_obs.transpose((1,0,2))\\n recentered.append(bg.transpose((1,0,2)))\\n recentered = np.array(recentered)\\n return recentered\\n # recentered = []\\n # obs = tf.constant(obs, dtype=tf.float32)\\n # for i in range(obs.shape[0]): ## iterate through envs\\n # one_obs = obs[i]\\n # piece = tf.transpose(one_obs[:][57:57+4][:], perm=[1,0,2])\\n # bg = tf.Variable(tf.zeros((64*2, 64, 3), dtype=tf.float32))\\n # diff_min = 100\\n # loc_min = -1\\n # for loc in range(64-3):\\n # block = piece[loc:loc+3]\\n # block = tf.transpose(block, perm=[1,0,2])\\n # diff = tf.math.abs(tf.reduce_sum(bot_norm - block/tf.norm(block)))\\n # evl = diff.eval() \\n # if evl < diff_min:\\n # diff_min = evl\\n # loc_min = loc\\n # blk = piece[loc_min:loc_min+3]\\n # #print(\\\"detected loc: \\\", loc_min)\\n # center = 62 - loc_min\\n # bg[center:center+64].assign(tf.transpose(one_obs, perm=[1,0,2]))\\n # recentered.append(tf.transpose(bg, perm=[1,0,2]))\\n # recentered = tf.constant(recentered)\\n # return recentered\",\n \"def pc_output_buffers_full(self, *args) -> \\\"std::vector< float,std::allocator< float > >\\\":\\n return _beamforming_swig.doaesprit_sptr_pc_output_buffers_full(self, *args)\",\n \"def _data_move_in_mc_on_w(tik_inst, dst, src, data_pos_info):\\n\\n sub_h_size, sub_w_size, h_size, w_size, w_offset = data_pos_info\\n data_cnt_one_block = _get_elment_cnt_one_block(src.dtype)\\n sub_w_block = _ceil_div(sub_w_size, data_cnt_one_block)\\n sub_h_align_block_size = sub_h_size // data_cnt_one_block * data_cnt_one_block\\n sub_h_left = sub_h_size % data_cnt_one_block\\n is_not_w_block_align = w_size % data_cnt_one_block > 0\\n is_h_size_smaller_one_block = h_size < data_cnt_one_block\\n\\n def _move_in_one_more_block():\\n \\\"\\\"\\\"\\n move in one more block of h when h > sub_h and sub_h is not block align\\n \\\"\\\"\\\"\\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx:\\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx],\\n src[w_offset + w_size * sub_h_idx], 0, 1, sub_w_block, 0, 0)\\n # in order to avoid dirty data when multiple core\\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block *\\n (sub_h_align_block_size + sub_h_idx_1)],\\n src[w_offset +\\n w_size * (sub_h_size - data_cnt_one_block + sub_h_idx_1)],\\n 0, 1, sub_w_block, 0, 0)\\n\\n with tik_inst.if_scope(is_not_w_block_align):\\n # sub_h is block align or h is not enough one block\\n with tik_inst.if_scope(tik.any(sub_h_left == 0, is_h_size_smaller_one_block)):\\n with tik_inst.for_range(0, sub_h_size) as sub_h_idx:\\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx],\\n src[w_offset + w_size * sub_h_idx], 0, 1, sub_w_block, 0, 0)\\n with tik_inst.else_scope():\\n _move_in_one_more_block()\\n\\n with tik_inst.else_scope():\\n with tik_inst.if_scope(tik.any(sub_h_left == 0, is_h_size_smaller_one_block)):\\n src_strides = w_size // data_cnt_one_block - sub_w_block\\n # mte max strides value is 65535\\n with tik_inst.if_scope(src_strides > MTE_STRIDES):\\n with tik_inst.for_range(0, sub_h_size) as sub_h_idx_2:\\n tik_inst.data_move(dst[sub_w_size * sub_h_idx_2],\\n src[w_offset + w_size * sub_h_idx_2],\\n 0, 1, sub_w_block, 0, 0)\\n with tik_inst.else_scope():\\n tik_inst.data_move(dst, src[w_offset], 0, sub_h_size, sub_w_block, src_strides, 0)\\n with tik_inst.else_scope():\\n _move_in_one_more_block()\",\n \"def warp(x, flo):\\n x=torch.squeeze(x,2)\\n flo=torch.squeeze(flo,2)\\n B, C, H, W = x.size()\\n # mesh grid \\n xx = torch.arange(0, W).view(1,-1).repeat(H,1)\\n yy = torch.arange(0, H).view(-1,1).repeat(1,W)\\n xx = xx.view(1,1,H,W).repeat(B,1,1,1)\\n yy = yy.view(1,1,H,W).repeat(B,1,1,1)\\n grid = torch.cat((xx,yy),1).float()\\n\\n #if x.is_cuda:\\n # grid = grid.cuda()\\n vgrid = torch.Tensor(grid).cuda() - flo.cuda()\\n\\n # scale grid to [-1,1] \\n vgrid[:,0,:,:] = 2.0*vgrid[:,0,:,:].clone() / max(W-1,1)-1.0\\n vgrid[:,1,:,:] = 2.0*vgrid[:,1,:,:].clone() / max(H-1,1)-1.0\\n\\n vgrid = vgrid.permute(0,2,3,1) \\n #x=x.cuda()\\n output = nn.functional.grid_sample(x, vgrid,mode='bilinear')\\n mask = torch.Tensor(torch.ones(x.size())).cuda()\\n mask = nn.functional.grid_sample(mask, vgrid,mode='bilinear')\\n\\n # if W==128:\\n # np.save('mask.npy', mask.cpu().data.numpy())\\n # np.save('warp.npy', output.cpu().data.numpy())\\n \\n mask[mask<0.9999] = 0\\n mask[mask>0] = 1\\n return torch.unsqueeze(output,2),torch.unsqueeze(mask,2)\",\n \"def _process(self, data: np.ndarray) -> np.ndarray:\\n\\n # Step 1. Reorder the data.\\n memory = self._reorder_iq(data)\\n\\n # Step 2. Subtract and take absolute value of consecutive IQ points in\\n # the reordered memory.\\n post_processed_memory = np.abs(np.diff(memory, axis=0))\\n\\n # The first element of the post-processed data is the first element\\n # of the reordered memory from step 1.\\n post_processed_memory = np.insert(post_processed_memory, 0, memory[0], axis=0)\\n\\n # Step 3. Order post-processed IQ points by circuit.\\n iq_memory = [[] for _ in range(self._n_circuits)]\\n for idx, iq_point in enumerate(post_processed_memory):\\n iq_memory[idx % self._n_circuits].append(iq_point)\\n\\n return np.array(iq_memory)\",\n \"def reshape(self, bottom, top):\\r\\n pass\",\n \"def update_boundary(self):\\n\\n cell = self._fire_boundary.dequeue()\\n neighbors = self.four_neighbors(cell[0], cell[1])\\n #neighbors = self.eight_neighbors(cell[0], cell[1])\\n for neighbor in neighbors:\\n if self.is_empty(neighbor[0], neighbor[1]):\\n self.set_full(neighbor[0], neighbor[1])\\n self._fire_boundary.enqueue(neighbor)\\n\\n # Check class invariant after update\\n assert self.boundary_invariant()\",\n \"def full_batch(self):\\n full_X, full_y = pad_sort_data(self.full_X, self.full_y)\\n return full_X, full_y\",\n \"def swipeBase (self) :\\n grid = self.grid\\n\\n #we start by putting every tile up\\n for columnNbr in range(4) :\\n nbrZeros = 4 - np.count_nonzero(grid[:,columnNbr])\\n\\n for lineNbr in range(4) :\\n counter = 0\\n while (grid[lineNbr, columnNbr] == 0) and (counter < 4):\\n counter += 1\\n if np.count_nonzero(grid[lineNbr:4, columnNbr]) != 0 :\\n for remainingLine in range (lineNbr, 3) :\\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\\n grid[3, columnNbr] = 0\\n\\n #now we do the additions\\n for lineNbr in range(3) :\\n if grid[lineNbr, columnNbr] == grid[lineNbr+1, columnNbr] :\\n grid[lineNbr, columnNbr] *= 2\\n for remainingLine in range (lineNbr+1, 3) :\\n grid[remainingLine, columnNbr] = grid[remainingLine+1, columnNbr]\\n grid[3, columnNbr] = 0\\n\\n return (grid)\",\n \"def reshape(self,bottom,top):\\n pass\",\n \"def prepare_rhs(self, simulation):\\n\\n nv = simulation.container.nv\\n sorder = simulation.container.sorder\\n nspace = [1] * (len(sorder) - 1)\\n v = self.stencil.get_all_velocities()\\n\\n gpu_support = simulation.container.gpu_support\\n\\n for key, value in self.value_bc.items():\\n if value is not None:\\n indices = np.where(self.ilabel == key)\\n # TODO: check the index in sorder to be the most contiguous\\n nspace[0] = indices[0].size\\n k = self.istore[0, indices]\\n\\n s = 1 - self.distance[indices]\\n coords = tuple()\\n for i in range(simulation.domain.dim):\\n x = simulation.domain.coords_halo[i][self.istore[i + 1, indices]]\\n x += s * v[k, i] * simulation.domain.dx\\n x = x.ravel()\\n for j in range(\\n 1, simulation.domain.dim\\n ): # pylint: disable=unused-variable\\n x = x[:, np.newaxis]\\n coords += (x,)\\n\\n m = Array(nv, nspace, 0, sorder, gpu_support=gpu_support)\\n m.set_conserved_moments(simulation.scheme.consm)\\n\\n f = Array(nv, nspace, 0, sorder, gpu_support=gpu_support)\\n f.set_conserved_moments(simulation.scheme.consm)\\n\\n args = coords\\n if isinstance(value, types.FunctionType):\\n func = value\\n elif isinstance(value, tuple):\\n func = value[0]\\n args += value[1]\\n\\n if self.time_bc[key]:\\n func(f, m, 0, *args)\\n else:\\n func(f, m, *args)\\n\\n simulation.equilibrium(m)\\n simulation.m2f(m, f)\\n\\n if self.generator.backend.upper() == \\\"LOOPY\\\":\\n f.array_cpu[...] = f.array.get()\\n\\n self.feq[:, indices[0]] = f.swaparray.reshape((nv, indices[0].size))\\n\\n if self.time_bc[key]:\\n self.func.append(func)\\n self.args.append(args)\\n self.f.append(f)\\n self.m.append(m)\\n self.indices.append(indices[0])\",\n \"def test_SetMultipleMovingLoadsReverseGeom(self):\\n\\n # create nodes\\n second_coord = [1, 0, 0.0]\\n self.mp.CreateNewNode(1, 0.0, 0.0, 0.0)\\n self.mp.CreateNewNode(2, second_coord[0], second_coord[1], 0.0)\\n\\n # create condition\\n self.mp.CreateNewCondition(\\\"MovingLoadCondition2D2N\\\", 1, [2, 1], self.mp.GetProperties()[1])\\n\\n parameters = self.base_parameters\\n\\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME,\\n 0)\\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.DELTA_TIME,\\n 0.25)\\n\\n process = GMA.SetMultipleMovingLoadsProcess(self.mp, parameters)\\n cond = self.cmp.GetCondition(2)\\n\\n # initialize and set load\\n process.ExecuteInitialize()\\n process.ExecuteInitializeSolutionStep()\\n\\n # initialise matrices\\n lhs = KratosMultiphysics.Matrix(0, 0)\\n rhs = KratosMultiphysics.Vector(0)\\n\\n # set load on node\\n # cond.SetValue(SMA.MOVING_LOAD_LOCAL_DISTANCE, 0)\\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\\n\\n self.checkRHS(rhs, [0.0, 0.0, 0.0, -2.0])\\n\\n # move load\\n process.ExecuteFinalizeSolutionStep()\\n process.ExecuteInitializeSolutionStep()\\n\\n # check if interpolation is done correctly\\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\\n\\n self.checkRHS(rhs, [0.0, -0.5, 0.0, -1.5])\",\n \"def _copy_to_gpu(self):\\n self.dispatch('on_texture')\",\n \"def _preprocessing(self):\\n if self.resize:\\n self.click_list = self._remapping_coord(self.click_list,\\n self.input_size,\\n self.orig_size)\\n clickers = self._get_clickers(self.click_list)\\n clicks_list = clickers.get_clicks()\\n clicks_lists = self._points_transform([clicks_list], self.image_width)\\n points_nd = self._get_points_nd(clicks_lists, self.net_clicks_limit)\\n return points_nd\",\n \"def _delayed_array_promotions(self):\\n for x in self.__delayed_promotions:\\n self._promote_family_array(*x)\\n\\n self.__delayed_promotions = []\",\n \"def pc_input_buffers_full(self, *args) -> \\\"std::vector< float,std::allocator< float > >\\\":\\n return _beamforming_swig.doaesprit_sptr_pc_input_buffers_full(self, *args)\",\n \"def _gen_mem_pre(self):\\n params = self._get_model_params()\\n\\n # because we cant easily get intermediate values from ONNX runtime\\n # use the pytorch value\\n mem_0 = np.zeros(2_850)\\n mem_1 = np.zeros(2_925)\\n\\n flat_input = np.ndarray.flatten(list(self.input_.values())[0])\\n\\n mem_0[: len(flat_input)] = flat_input\\n\\n tensors = params + [mem_0, mem_1]\\n flat_tensors = [np.ndarray.flatten(tensor) for tensor in tensors]\\n\\n self.mem_pre = [f\\\"{x}\\\\n\\\" for tensor in flat_tensors for x in tensor.tolist()]\",\n \"def pin_memory(self):\\r\\n\\r\\n self.points = [in_tensor.pin_memory() for in_tensor in self.points]\\r\\n self.neighbors = [in_tensor.pin_memory() for in_tensor in self.neighbors]\\r\\n self.pools = [in_tensor.pin_memory() for in_tensor in self.pools]\\r\\n self.upsamples = [in_tensor.pin_memory() for in_tensor in self.upsamples]\\r\\n self.lengths = [in_tensor.pin_memory() for in_tensor in self.lengths]\\r\\n self.features = self.features.pin_memory()\\r\\n\\r\\n return self\",\n \"def main():\\n\\n # Create an empty array to hold our points.\\n n = gpuarray.zeros(shape=(x, y, z),\\n dtype=gpuarray.vec.float3)\\n\\n # Populate the array with randomized points from the search space.\\n for k in range(z):\\n for j in range(y):\\n for i in range(x):\\n n[i, j, k] = gpuarray.vec.make_float3(random.uniform(-width, width),\\n random.uniform(-height, height),\\n random.uniform(-depth, depth))\\n\\n # Declare our elementwise CUDA kernel.\\n mod = Elementwise(\\n arguments=\\\"float3 pt, float3 *ns, float *rs\\\",\\n operation=\\\"rs[i] = sqrt(pow(pt.x-ns[i].x,2)+pow(pt.y-ns[i].y,2)+pow(pt.z-ns[i].z,2))\\\",\\n name=\\\"euclidean_distance\\\",\\n preamble=\\\"#include <math.h>\\\"\\n )\\n\\n # Declare an empty results array.\\n r = gpuarray.zeros(shape=(50, 50, 2), dtype=numpy.float32)\\n start = cuda.Event()\\n end = cuda.Event()\\n start.record()\\n # Call the kernel with a randomize point from the search space.\\n mod(gpuarray.vec.make_float3(random.uniform(-width, width),\\n random.uniform(-height, height),\\n random.uniform(-width, width)), n, r)\\n end.record()\\n end.synchronize()\\n print((start.time_till(end)))\\n print(r)\",\n \"def move(self):\\n x = y = z = 0.0\\n for cell in self.cells:\\n x += (cell.x)#*n\\n y += (cell.y)#*n\\n z += (cell.z)#*n\\n np = float(len(self.cells))\\n med = numpy.array([x/np,y/np,z/np])\\n \\n dists = []\\n for cell in self.cells:\\n d = (cell.x-self.x)**2+(cell.y-self.y)**2+(cell.z-self.z)**2\\n d = numpy.sqrt(d)\\n dists.append(d)\\n #md = (cell.x-med[0])**2+(cell.y-med[1])**2+(cell.z-med[2])**2\\n #dists[-1] = (dists[-1]+md)/2\\n cell = self.cells[numpy.argmin(dists)]\\n cc = numpy.array([cell.x, cell.y, cell.z])\\n \\n t = self.t\\n if abs(self.dnp) * ( self.np-self.np_req) > 0:\\n t = self.tr\\n self.dcenter = (1-t)*(med-self.center + self.u*(cc-med))\\n self.x,self.y,self.z = self.center = self.center + self.dcenter\",\n \"def free_intermediate_arrays(self):\\n self._mgx = None\\n self._mgy = None\\n self._mgz = None\\n self._vander = None\\n self._bkg_cube = None\\n self._bkg_cube_dirty = True\",\n \"def _cell_to_global(self, xy, wh):\\n # grid setup\\n line = tf.range(0, self.num_cells)\\n rows = tf.reshape(line, [self.num_cells, 1])\\n rows = tf.tile(rows, [1, self.num_cells])\\n cols = tf.reshape(line, [1, self.num_cells])\\n cols = tf.tile(cols, [self.num_cells, 1])\\n grid = tf.stack([cols, rows], axis=-1)\\n grid = tf.reshape(grid, [1, self.num_cells, self.num_cells, 1, 2])\\n grid = tf.cast(grid, tf.float32)\\n # box transformation\\n xy += grid\\n wh *= tf.reshape(self.anchors, [1, 1, 1, self.num_anchors, 2])\\n return tf.concat([xy, wh], axis=-1) / self.num_cells\",\n \"def _compute_boundaries_embedding(self, boundaries):\\n # Check if boundaries have been determined before\\n boundaries_hash = hash(boundaries[self.n_keep_dims:].tostring())\\n if boundaries_hash in self.boundaries_cache:\\n boundaries_embedded = \\\\\\n np.array(self.boundaries_cache[boundaries_hash])\\n boundaries_embedded[:self.n_keep_dims] = \\\\\\n boundaries[:self.n_keep_dims] # Overwrite keep-dim's boundaries\\n return boundaries_embedded\\n\\n # Determine boundaries on embedded space\\n boundaries_embedded = \\\\\\n np.empty((self.n_keep_dims + self.d_embedding, 2))\\n boundaries_embedded[:self.n_keep_dims] = boundaries[:self.n_keep_dims]\\n for dim in range(self.n_keep_dims,\\n self.n_keep_dims + self.d_embedding):\\n x_embedded = np.zeros(self.n_keep_dims + self.d_embedding)\\n while True:\\n x = self._manifold_to_dataspace(x_embedded)\\n if np.sum(np.logical_or(\\n x[self.n_keep_dims:] < boundaries[self.n_keep_dims:, 0],\\n x[self.n_keep_dims:] > boundaries[self.n_keep_dims:,\\n 1])) \\\\\\n > (self.d_orig - self.n_keep_dims) / 2:\\n break\\n x_embedded[dim] -= 0.01\\n boundaries_embedded[dim, 0] = x_embedded[dim]\\n\\n x_embedded = np.zeros(self.n_keep_dims + self.d_embedding)\\n while True:\\n x = self._manifold_to_dataspace(x_embedded)\\n if np.sum(np.logical_or(\\n x[self.n_keep_dims:] < boundaries[self.n_keep_dims:, 0],\\n x[self.n_keep_dims:] > boundaries[self.n_keep_dims:, 1])) \\\\\\n > (self.d_orig - self.n_keep_dims) / 2:\\n break\\n x_embedded[dim] += 0.01\\n boundaries_embedded[dim, 1] = x_embedded[dim]\\n\\n self.boundaries_cache[boundaries_hash] = boundaries_embedded\\n\\n return boundaries_embedded\",\n \"def data_move_case_zero(tik_instance, ub_ori, ub_trans,\\n is_last, num_outer_axis, num_loop_time,\\n loop_time, loop_col, loop_len):\\n with tik_instance.if_scope(tik.all(loop_time ==\\n self.dst_shape[-4] //\\n loop_col - 1,\\n self.dst_shape[-4] % loop_col ==\\n 0)):\\n is_last.set_as(1)\\n num_data_one_loop = self.dst_shape[-4] * self.dst_shape[-3] * \\\\\\n self.dst_shape[-2] * self.dst_shape[-1]\\n src_ub_index = 0\\n if self.src_shape[-1] % CUBE_SIZE != 0 or \\\\\\n (self.src_shape[-1] - loop_len * CUBE_SIZE) // \\\\\\n self.num_data > MAX_STRIDE_BLK:\\n if self.src_shape[-2] % CUBE_SIZE != 0:\\n with tik_instance.if_scope(num_loop_time ==\\n self.dst_shape[-3] - 1):\\n with tik_instance.for_range(0,\\n self.src_shape[-2] %\\n CUBE_SIZE) as num_cube_col:\\n src_gm_index = num_outer_axis *\\\\\\n self.src_shape[-1] * \\\\\\n self.src_shape[-2] + \\\\\\n (num_loop_time * CUBE_SIZE +\\n num_cube_col) *\\\\\\n self.src_shape[-1] + loop_time *\\\\\\n loop_col * CUBE_SIZE\\n tik_instance.data_move(ub_ori[loop_len *\\n CUBE_SIZE *\\n num_cube_col],\\n self.src_gm[src_gm_index],\\n 0, 1,\\n loop_len * self.num_byte //\\n 2, 0, 0)\\n with tik_instance.else_scope():\\n with tik_instance.for_range(0, CUBE_SIZE) \\\\\\n as num_cube_col:\\n src_gm_index = num_outer_axis * \\\\\\n self.src_shape[-1] * \\\\\\n self.src_shape[-2] + \\\\\\n (num_loop_time * CUBE_SIZE +\\n num_cube_col) *\\\\\\n self.src_shape[-1] + loop_time *\\\\\\n loop_col * CUBE_SIZE\\n tik_instance.data_move(ub_ori[loop_len *\\n CUBE_SIZE *\\n num_cube_col],\\n self.src_gm[src_gm_index],\\n 0, 1,\\n loop_len * self.num_byte //\\n 2, 0, 0)\\n else:\\n with tik_instance.for_range(0, CUBE_SIZE) as num_cube_col:\\n src_gm_index = num_outer_axis * self.src_shape[-1] * \\\\\\n self.src_shape[-2] + \\\\\\n (num_loop_time * CUBE_SIZE +\\n num_cube_col) * self.src_shape[-1] + \\\\\\n loop_time * loop_col * CUBE_SIZE\\n tik_instance.data_move(ub_ori[loop_len * CUBE_SIZE *\\n num_cube_col],\\n self.src_gm[src_gm_index],\\n 0, 1,\\n loop_len * self.num_byte //\\n 2, 0, 0)\\n else:\\n src_gm_index = num_outer_axis * self.src_shape[-1] * \\\\\\n self.src_shape[-2] + num_loop_time *\\\\\\n CUBE_SIZE * self.src_shape[-1] +\\\\\\n loop_time * loop_col * CUBE_SIZE\\n if self.src_shape[-2] % CUBE_SIZE != 0:\\n with tik_instance.if_scope(num_loop_time ==\\n self.dst_shape[-3] - 1):\\n tik_instance.data_move(ub_ori[src_ub_index],\\n self.src_gm[src_gm_index], 0,\\n self.src_shape[-2] % CUBE_SIZE,\\n loop_len * self.num_byte // 2,\\n (self.src_shape[-1] -\\n loop_len * CUBE_SIZE) //\\n self.num_data,\\n 0)\\n with tik_instance.else_scope():\\n tik_instance.data_move(ub_ori[src_ub_index],\\n self.src_gm[src_gm_index],\\n 0, CUBE_SIZE,\\n loop_len * self.num_byte // 2,\\n (self.src_shape[-1] -\\n loop_len * CUBE_SIZE) //\\n self.num_data,\\n 0)\\n else:\\n tik_instance.data_move(ub_ori[src_ub_index],\\n self.src_gm[src_gm_index],\\n 0, CUBE_SIZE,\\n loop_len * self.num_byte // 2,\\n (self.src_shape[-1] - loop_len *\\n CUBE_SIZE) // self.num_data, 0)\\n self.data_rearrange_case_four(tik_instance, ub_ori,\\n ub_trans, num_loop_time,\\n loop_len, is_last)\\n\\n if((self.dst_shape[-3] - 1) * self.dst_shape[-1] *\\n self.dst_shape[-2] // self.num_data > MAX_STRIDE_BLK):\\n with tik_instance.for_range(0, loop_len) as \\\\\\n num_col_cube:\\n dst_gm_index = num_outer_axis * num_data_one_loop + \\\\\\n num_loop_time * self.dst_shape[-1] * \\\\\\n self.dst_shape[-2] + \\\\\\n (loop_time * loop_col + num_col_cube) * \\\\\\n self.dst_shape[-1] * self.dst_shape[-2] * \\\\\\n self.dst_shape[-3]\\n tik_instance.data_move(self.dst_gm[dst_gm_index],\\n ub_trans[num_col_cube *\\n CUBE_SIZE *\\n (CUBE_SIZE + 1)],\\n 0, 1,\\n self.dst_shape[-1] *\\n self.dst_shape[-2] //\\n self.num_data,\\n 0, 0)\\n else:\\n dst_gm_index = num_outer_axis * num_data_one_loop + \\\\\\n num_loop_time * self.dst_shape[-1] * \\\\\\n self.dst_shape[-2] + loop_time * \\\\\\n loop_col * self.dst_shape[-1] * \\\\\\n self.dst_shape[-2] * \\\\\\n self.dst_shape[-3]\\n tik_instance.data_move(self.dst_gm[dst_gm_index],\\n ub_trans[0],\\n 0, loop_len,\\n self.dst_shape[-1] *\\n self.dst_shape[-2] // self.num_data,\\n self.num_byte // 2,\\n (self.dst_shape[-3] - 1) *\\n self.dst_shape[-1] *\\n self.dst_shape[-2] // self.num_data)\",\n \"def spatial_batchnorm_backward(dout, cache):\\n dx, dgamma, dbeta = None, None, None\\n\\n #############################################################################\\n # TODO: Implement the backward pass for spatial batch normalization. #\\n # #\\n # HINT: You can implement spatial batch normalization using the vanilla #\\n # version of batch normalization defined above. Your implementation should #\\n # be very short; ours is less than five lines. #\\n #############################################################################\\n pass\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n return dx, dgamma, dbeta\",\n \"def spatial_batchnorm_backward(dout, cache):\\r\\n \\tN, C, H, W = dout.shape\\r\\n dout_new = dout.transpose(0, 2, 3, 1).reshape(N*H*W, C)\\r\\n dx, dgamma, dbeta = batchnorm_backward(dout_new, cache)\\r\\n dx = dx.reshape(N, H, W, C).transpose(0, 3, 1, 2)\\r\\n\\r\\n return dx, dgamma, dbeta\",\n \"def data_move_case_zero(self, tik_instance, ub_ori, ub_cast_fp16, ub_trans,\\n ub_cast_int8, is_last, num_outer_axis,\\n num_loop_time, loop_time, loop_col, loop_len):\\n with tik_instance.if_scope(tik.all(loop_time == self.dst_shape[-4] //\\n loop_col - 1,\\n self.dst_shape[-4] % loop_col ==\\n 0)):\\n is_last.set_as(1)\\n num_data_one_loop = self.dst_shape[-4] * self.dst_shape[-3] * \\\\\\n self.dst_shape[-2] * self.dst_shape[-1]\\n src_ub_index = 0\\n if self.src_shape[-1] % CUBE_SIZE_2 != 0 or \\\\\\n (self.src_shape[-1] - loop_len * CUBE_SIZE_2) // \\\\\\n self.num_data > MAX_STRIDE_BLK:\\n with tik_instance.if_scope(num_loop_time ==\\n self.dst_shape[-3] - 1):\\n if self.src_shape[-2] % CUBE_SIZE != 0:\\n with tik_instance.for_range(0, self.src_shape[-2] %\\n CUBE_SIZE) as num_cube_col:\\n src_gm_index = num_outer_axis * self.src_shape[-1] * \\\\\\n self.src_shape[-2] + \\\\\\n (num_loop_time * CUBE_SIZE +\\n num_cube_col) * self.src_shape[-1] + \\\\\\n loop_time * loop_col * CUBE_SIZE_2\\n tik_instance.data_move(ub_ori[loop_len *\\n CUBE_SIZE_2 *\\n num_cube_col],\\n self.src_gm[src_gm_index],\\n 0, 1,\\n loop_len * CUBE_SIZE_2 //\\n self.num_data, 0, 0)\\n else:\\n with tik_instance.for_range(0, CUBE_SIZE) \\\\\\n as num_cube_col:\\n src_gm_index = num_outer_axis * self.src_shape[-1] * \\\\\\n self.src_shape[-2] + \\\\\\n (num_loop_time * CUBE_SIZE +\\n num_cube_col) * self.src_shape[-1] + \\\\\\n loop_time * loop_col * CUBE_SIZE_2\\n tik_instance.data_move(ub_ori[loop_len *\\n CUBE_SIZE_2 *\\n num_cube_col],\\n self.src_gm[src_gm_index],\\n 0, 1,\\n loop_len * CUBE_SIZE_2 //\\n self.num_data, 0, 0)\\n with tik_instance.else_scope():\\n with tik_instance.for_range(0, CUBE_SIZE) as num_cube_col:\\n src_gm_index = num_outer_axis * self.src_shape[-1] * \\\\\\n self.src_shape[-2] + \\\\\\n (num_loop_time * CUBE_SIZE +\\n num_cube_col) * self.src_shape[-1] + \\\\\\n loop_time * loop_col * CUBE_SIZE_2\\n tik_instance.data_move(ub_ori[loop_len * CUBE_SIZE_2 *\\n num_cube_col],\\n self.src_gm[src_gm_index],\\n 0, 1,\\n loop_len * CUBE_SIZE_2 //\\n self.num_data, 0, 0)\\n else:\\n src_gm_index = num_outer_axis * self.src_shape[-1] * \\\\\\n self.src_shape[-2] + num_loop_time * CUBE_SIZE * \\\\\\n self.src_shape[-1] + loop_time * loop_col * \\\\\\n CUBE_SIZE_2\\n with tik_instance.if_scope(num_loop_time ==\\n self.dst_shape[-3] - 1):\\n if self.src_shape[-2] % CUBE_SIZE != 0:\\n tik_instance.data_move(ub_ori[src_ub_index],\\n self.src_gm[src_gm_index], 0,\\n self.src_shape[-2] % CUBE_SIZE,\\n loop_len,\\n (self.src_shape[-1] -\\n loop_len * CUBE_SIZE_2) //\\n self.num_data,\\n 0)\\n else:\\n tik_instance.data_move(ub_ori[src_ub_index],\\n self.src_gm[src_gm_index],\\n 0, CUBE_SIZE,\\n loop_len,\\n (self.src_shape[-1] -\\n loop_len * CUBE_SIZE_2) //\\n self.num_data,\\n 0)\\n with tik_instance.else_scope():\\n tik_instance.data_move(ub_ori[src_ub_index],\\n self.src_gm[src_gm_index],\\n 0, CUBE_SIZE,\\n loop_len,\\n (self.src_shape[-1] - loop_len *\\n CUBE_SIZE_2) // self.num_data, 0)\\n\\n self.data_rearrange_case_one(tik_instance, ub_ori, ub_cast_fp16,\\n ub_trans, ub_cast_int8, num_loop_time,\\n loop_len, is_last)\\n\\n if((self.dst_shape[-3] - 1) * self.dst_shape[-1] *\\n self.dst_shape[-2] // self.num_data > MAX_STRIDE_BLK):\\n with tik_instance.for_range(0, loop_len) as \\\\\\n num_col_cube:\\n dst_gm_index = num_outer_axis * num_data_one_loop + \\\\\\n num_loop_time * self.dst_shape[-1] * \\\\\\n self.dst_shape[-2] + \\\\\\n (loop_time * loop_col + num_col_cube) * \\\\\\n self.dst_shape[-1] * self.dst_shape[-2] * \\\\\\n self.dst_shape[-3]\\n tik_instance.data_move(self.dst_gm[dst_gm_index],\\n ub_cast_int8[num_col_cube *\\n CUBE_SIZE_2 *\\n (CUBE_SIZE + 1)],\\n 0, 1,\\n self.dst_shape[-1] *\\n self.dst_shape[-2] //\\n self.num_data,\\n 0, 0)\\n else:\\n dst_gm_index = num_outer_axis * num_data_one_loop + \\\\\\n num_loop_time * self.dst_shape[-1] * \\\\\\n self.dst_shape[-2] + loop_time * \\\\\\n loop_col * self.dst_shape[-1] * \\\\\\n self.dst_shape[-2] * \\\\\\n self.dst_shape[-3]\\n tik_instance.data_move(self.dst_gm[dst_gm_index],\\n ub_cast_int8[0],\\n 0, loop_len,\\n self.dst_shape[-1] * self.dst_shape[-2] //\\n self.num_data, self.num_byte,\\n (self.dst_shape[-3] - 1) *\\n self.dst_shape[-1] *\\n self.dst_shape[-2] // self.num_data)\",\n \"def local_to_global(npboxes: np.ndarray, window: Box):\\n xmin = window.xmin\\n ymin = window.ymin\\n return npboxes + np.array([[ymin, xmin, ymin, xmin]])\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def reshape(self, bottom, top):\\n pass\",\n \"def _process_operations(self, operations: List[MemoryOperation], slices: SlicesType = None) -> None:\\n for op in operations:\\n if op.inst == MemoryOperation.NOOP:\\n pass # do nothing\\n elif op.inst == MemoryOperation.LOAD:\\n if MemoryOperation.LOAD_SUBARRAY in op.flag:\\n # build slices mapping first\\n self._array.set_slices_mapping(op.dst, slices)\\n\\n # check flag to see if dst is current device\\n dst_is_current_device = op.flag != MemoryOperation.SWITCH_DEVICE_FLAG\\n\\n # copy data\\n if num_gpu > 0:\\n cupy.cuda.stream.get_current_stream().synchronize()\\n \\n self._array.copy_data_between_device(\\n op.dst, op.src, dst_is_current_device)\\n\\n # sync stream before set it as ready, so asyc call is ensured to be done\\n if num_gpu > 0:\\n cupy.cuda.stream.get_current_stream().synchronize()\\n elif op.inst == MemoryOperation.EVICT:\\n # decrement the reference counter, relying on GC to free the memor\\n self._array.clear(op.src)\\n elif op.inst == MemoryOperation.ERROR:\\n raise RuntimeError(\\\"PArray gets an error from coherence protocol\\\")\\n else:\\n raise RuntimeError(f\\\"PArray gets invalid memory operation from coherence protocol, \\\"\\n f\\\"detail: opcode {op.inst}, dst {op.dst}, src {op.src}\\\")\",\n \"def grid_displacement_pc(grid1, grid2, field, level, return_value=\\\"pixels\\\"):\\n # create copies of the data\\n field_data1 = grid1.fields[field][\\\"data\\\"][level].copy()\\n field_data2 = grid2.fields[field][\\\"data\\\"][level].copy()\\n\\n # replace fill values with valid_min or minimum value in array\\n if \\\"valid_min\\\" in grid1.fields[field]:\\n min_value1 = grid1.fields[field][\\\"valid_min\\\"]\\n else:\\n min_value1 = field_data1.min()\\n field_data1 = np.ma.filled(field_data1, min_value1)\\n\\n if \\\"valid_min\\\" in grid2.fields[field]:\\n min_value2 = grid2.fields[field][\\\"valid_min\\\"]\\n else:\\n min_value2 = field_data2.min()\\n field_data2 = np.ma.filled(field_data2, min_value2)\\n\\n # discrete fast fourier transformation and complex conjugation of field 2\\n image1fft = np.fft.fft2(field_data1)\\n image2fft = np.conjugate(np.fft.fft2(field_data2))\\n\\n # inverse fourier transformation of product -> equal to cross correlation\\n imageccor = np.real(np.fft.ifft2(image1fft * image2fft))\\n\\n # shift the zero-frequency component to the center of the spectrum\\n imageccorshift = np.fft.fftshift(imageccor)\\n\\n # determine the distance of the maximum from the center\\n # find the peak in the correlation\\n row, col = field_data1.shape\\n yshift, xshift = np.unravel_index(np.argmax(imageccorshift), (row, col))\\n yshift -= int(row / 2)\\n xshift -= int(col / 2)\\n\\n dx = grid1.x[\\\"data\\\"][1] - grid1.x[\\\"data\\\"][0]\\n dy = grid1.y[\\\"data\\\"][1] - grid1.y[\\\"data\\\"][0]\\n x_movement = xshift * dx\\n y_movement = yshift * dy\\n\\n if return_value == \\\"pixels\\\":\\n displacement = (yshift, xshift)\\n elif return_value == \\\"distance\\\":\\n displacement = (y_movement, x_movement)\\n elif return_value == \\\"velocity\\\":\\n t1 = num2date(grid1.time[\\\"data\\\"][0], grid1.time[\\\"units\\\"])\\n t2 = num2date(grid2.time[\\\"data\\\"][0], grid2.time[\\\"units\\\"])\\n dt = (t2 - t1).total_seconds()\\n u = x_movement / dt\\n v = y_movement / dt\\n displacement = (v, u)\\n else:\\n displacement = (yshift, xshift)\\n return displacement\",\n \"def _fp32_1_0_2_mc_on_1_last_dim_lt_one_block(loop_cnt, left_data):\\n\\n # two case:\\n # 1. axis_0 * axis_2 > alloc_ub_size // 2, max_core_axis_size = 1\\n # 2. axis_0 * axis_2 <= alloc_ub_size // 2, axis_0_loop_cnt = 0, max_core_axis_size != 1\\n\\n def _fp32_mte_process_lt_one_block(axis_1_lp_index, sub_axis_1):\\n \\\"\\\"\\\"\\n do transpose for last dim less than one block\\n \\\"\\\"\\\"\\n\\n def _fp32_inner_last_dim_lt_one_block(axis_0_lp_index, sub_axis_0):\\n \\\"\\\"\\\"\\n inner process of last dim less than one block\\n \\\"\\\"\\\"\\n\\n # move data in\\n in_offset = (block_idx * per_core_col_size +\\n axis_1_lp_index * max_core_axis_size +\\n axis_0_lp_index * max_no_core_axis_size * axis_1) * axis_2\\n data_pos_info = (sub_axis_1, sub_axis_0, axis_0, axis_1, axis_2, in_offset)\\n _data_move_in_last_dim_lt_one_block(tik_inst, ub_input, data_in, data_pos_info)\\n\\n # do transpose\\n with tik_inst.new_stmt_scope():\\n temp_sub_axis_1 = tik_inst.Scalar(\\\"int64\\\")\\n temp_sub_axis_0 = tik_inst.Scalar(\\\"int64\\\")\\n data_size_one_block = _get_elment_cnt_one_block(data_in.dtype)\\n axis_1_0_2_size = axis_0 * axis_1 * axis_2\\n sub_axis_1_0_2_size = sub_axis_1 * sub_axis_0 * axis_2\\n\\n # to avoid multiple core dirty data\\n with tik_inst.if_scope(tik.all(sub_axis_1_0_2_size < data_size_one_block,\\n axis_1_0_2_size > data_size_one_block)):\\n with tik_inst.if_scope(sub_axis_1 == 1):\\n temp_sub_axis_0.set_as(_ceil_div(data_size_one_block, axis_2))\\n temp_sub_axis_1.set_as(sub_axis_1)\\n with tik_inst.else_scope():\\n temp_sub_axis_0.set_as(sub_axis_0)\\n temp_sub_axis_1.set_as(_ceil_div(data_size_one_block,\\n axis_0 * axis_2))\\n with tik_inst.else_scope():\\n temp_sub_axis_1.set_as(sub_axis_1)\\n temp_sub_axis_0.set_as(sub_axis_0)\\n\\n sub_dim_size = (temp_sub_axis_1, temp_sub_axis_0, axis_2)\\n _transpose_by_2_vnchwconv_not_last_dim(tik_inst, ub_input[ub_offset],\\n ub_input, sub_dim_size)\\n\\n # move data out\\n out_offset = ((block_idx * per_core_col_size +\\n axis_1_lp_index * max_core_axis_size) * axis_0 +\\n axis_0_lp_index * max_no_core_axis_size) * axis_2\\n data_pos_info = (sub_axis_1, sub_axis_0, axis_0, axis_1, axis_2, out_offset)\\n _data_move_out_last_dim_lt_one_block(tik_inst, data_out, ub_input[ub_offset],\\n data_pos_info)\\n\\n with tik_inst.for_range(0, no_core_loop_cnt) as axis_0_lp_idx:\\n _fp32_inner_last_dim_lt_one_block(axis_0_lp_idx, max_no_core_axis_size)\\n with tik_inst.if_scope(no_core_left > 0):\\n _fp32_inner_last_dim_lt_one_block(no_core_loop_cnt, no_core_left)\\n\\n with tik_inst.for_range(0, loop_cnt) as axis_1_lp_idx:\\n _fp32_mte_process_lt_one_block(axis_1_lp_idx, max_core_axis_size)\\n with tik_inst.if_scope(left_data > 0):\\n _fp32_mte_process_lt_one_block(loop_cnt, left_data)\",\n \"def _compute_rwg0_space_data(\\n support,\\n edge_neighbors,\\n edge_neighbors_ptr,\\n element_edges,\\n number_of_elements,\\n number_of_edges,\\n include_boundary_dofs,\\n truncate_at_segment_edge,\\n):\\n local2global_map = _np.zeros((number_of_elements, 3), dtype=_np.uint32)\\n local_multipliers = _np.zeros((number_of_elements, 3), dtype=_np.float64)\\n edge_dofs = -_np.ones(number_of_edges, dtype=_np.int32)\\n\\n dof_count = 0\\n for element in _np.flatnonzero(support):\\n has_dof = False\\n for local_index in range(3):\\n edge_index = element_edges[local_index, element]\\n if edge_dofs[edge_index] != -1:\\n has_dof = True\\n else:\\n current_neighbors = edge_neighbors[\\n edge_neighbors_ptr[edge_index] : edge_neighbors_ptr[1 + edge_index]\\n ]\\n supported_neighbors = [e for e in current_neighbors if support[e]]\\n if len(supported_neighbors) == 2:\\n if edge_dofs[edge_index]:\\n edge_dofs[edge_index] = dof_count\\n dof_count += 1\\n has_dof = True\\n if len(supported_neighbors) == 1 and include_boundary_dofs:\\n if edge_dofs[edge_index]:\\n edge_dofs[edge_index] = dof_count\\n dof_count += 1\\n has_dof = True\\n if not truncate_at_segment_edge:\\n for cell in current_neighbors:\\n # Add the element to the support\\n support[cell] = True\\n if not has_dof:\\n # If the element has no DOFs, remove it from support\\n support[element] = False\\n\\n for element_index in _np.flatnonzero(support):\\n dofmap = -_np.ones(3, dtype=_np.int32)\\n for local_index in range(3):\\n edge_index = element_edges[local_index, element_index]\\n if edge_dofs[edge_index] != -1:\\n dofmap[local_index] = edge_dofs[edge_index]\\n\\n current_neighbors = edge_neighbors[\\n edge_neighbors_ptr[edge_index] : edge_neighbors_ptr[1 + edge_index]\\n ]\\n supported_neighbors = [e for e in current_neighbors if support[e]]\\n\\n if len(supported_neighbors) == 1:\\n local_multipliers[element_index, local_index] = 1\\n else:\\n # Assign 1 or -1 depending on element index\\n local_multipliers[element_index, local_index] = (\\n 1 if element_index == min(supported_neighbors) else -1\\n )\\n\\n # For every zero local multiplier assign an existing global dof\\n # in this element. This does not change the result as zero multipliers\\n # do not contribute. But it allows us not to have to distinguish between\\n # existing and non existing dofs later on.\\n first_nonzero = 0\\n for local_index in range(3):\\n if local_multipliers[element_index, local_index] != 0:\\n first_nonzero = local_index\\n break\\n\\n for local_index in range(3):\\n if local_multipliers[element_index, local_index] == 0:\\n dofmap[local_index] = dofmap[first_nonzero]\\n local2global_map[element_index, :] = dofmap\\n\\n return dof_count, support, local2global_map, local_multipliers\",\n \"def spatial_batchnorm_backward(dout, cache):\\n dx, dgamma, dbeta = None, None, None\\n\\n ###########################################################################\\n # TODO: Implement the backward pass for spatial batch normalization. #\\n # #\\n # HINT: You can implement spatial batch normalization using the vanilla #\\n # version of batch normalization defined above. Your implementation should#\\n # be very short; ours is less than five lines. #\\n ###########################################################################\\n s_cache,shape_x = cache\\n reshaped_dout = np.reshape(dout,(-1,dout.shape[1]))\\n dx_reshaped,dgamma,dbeta = batchnorm_backward_alt(reshaped_dout,s_cache)\\n dx = np.reshape(dx_reshaped,shape_x)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n\\n return dx, dgamma, dbeta\",\n \"def pull(self,x,y):\\n\\t\\tself.x_sum -= np.sum(x,axis=0)[:,np.newaxis]\\n\\t\\tself.y_sum -= np.sum(y,axis=0)[:,np.newaxis]\\n\\t\\tself.xy_sum -= np.matmul(np.transpose(x),y)\\n\\t\\tself.xx_sum -= np.matmul(np.transpose(x),x)\\n\\t\\tself.yy_sum -= np.matmul(np.transpose(y),y)\\n\\t\\tself.n -= np.shape(x)[0]\",\n \"def scatter_array_scatterv_no_cache(self,geoMeta,src_array,ConfigOptions):\\n\\n\\n # Determine which type of input array we have based on the\\n # type of numpy array.\\n data_type_flag = -1\\n if self.rank == 0:\\n if src_array.dtype == np.float32:\\n data_type_flag = 1\\n if src_array.dtype == np.float64:\\n data_type_flag = 2\\n if src_array.dtype == np.bool:\\n data_type_flag = 3\\n\\n # Broadcast the data_type_flag to other processors\\n if self.rank == 0:\\n data_type_buffer = np.array([data_type_flag],np.int32)\\n else:\\n data_type_buffer = np.empty(1,np.int32)\\n\\n try:\\n self.comm.Bcast(data_type_buffer, root=0)\\n except:\\n ConfigOptions.errMsg = \\\"Unable to broadcast numpy datatype value from rank 0\\\"\\n err_handler.err_out(ConfigOptions)\\n return None\\n\\n data_type_flag = data_type_buffer[0]\\n data_type_buffer = None\\n\\n # gather buffer offsets and bounds to rank 0\\n bounds = np.array(\\n [np.int32(geoMeta.x_lower_bound), np.int32(geoMeta.y_lower_bound),\\n np.int32(geoMeta.x_upper_bound), np.int32(geoMeta.y_upper_bound)])\\n global_bounds = np.zeros((self.size*4),np.int32)\\n\\n try:\\n self.comm.Allgather([bounds, MPI.INTEGER], [global_bounds, MPI.INTEGER])\\n except:\\n ConfigOptions.errMsg = \\\"Failed all gathering global bounds at rank\\\" + str(self.rank)\\n err_handler.err_out(ConfigOptions)\\n return None\\n\\n # create slices for x and y bounds arrays\\n x_lower = global_bounds[0:(self.size * 4) + 0:4]\\n y_lower = global_bounds[1:(self.size * 4) + 1:4]\\n x_upper = global_bounds[2:(self.size * 4) + 2:4]\\n y_upper = global_bounds[3:(self.size * 4) + 3:4]\\n\\n # generate counts\\n counts = [ (y_upper[i] - y_lower[i]) * (x_upper[i] - x_lower[i])\\n for i in range(0,self.size)]\\n\\n #generate offsets:\\n offsets = [0]\\n for i in range(0, self.size - 1):\\n offsets.append(offsets[i] + counts[i])\\n\\n # create the send buffer\\n if self.rank == 0:\\n sendbuf = np.empty([src_array.size],src_array.dtype)\\n\\n # fill the send buffer\\n for i in range(0,self.size):\\n start = offsets[i]\\n stop = offsets[i]+counts[i]\\n sendbuf[start:stop] = src_array[y_lower[i]:y_upper[i],\\n x_lower[i]:x_upper[i]].flatten()\\n else:\\n sendbuf = None\\n\\n #create the recvbuffer\\n if data_type_flag == 1:\\n data_type = MPI.FLOAT\\n recvbuf=np.empty([counts[self.rank]],np.float32)\\n elif data_type_flag == 3: \\n data_type = MPI.BOOL\\n recvbuf = np.empty([counts[self.rank]], np.bool)\\n else:\\n data_type = MPI.DOUBLE\\n recvbuf = np.empty([counts[self.rank]], np.float64)\\n\\n #scatter the data\\n try:\\n self.comm.Scatterv( [sendbuf, counts, offsets, data_type], recvbuf, root=0)\\n except:\\n ConfigOptions.errMsg = \\\"Failed Scatterv from rank 0\\\"\\n err_handler.error_out(ConfigOptions)\\n return None\\n\\n subarray = np.reshape(recvbuf,[y_upper[self.rank] -y_lower[self.rank],x_upper[self.rank]- x_lower[self.rank]]).copy()\\n return subarray\",\n \"def _gm_to_ub_one(args):\\n tik_instance, data, data_ub, data_offset, ub_offset, ori_nburst, \\\\\\n burst_len, src_stride, dst_stride, cp_align_len = args\\n\\n if src_stride <= 65535:\\n if ori_nburst <= 4095:\\n tik_instance.data_move(data_ub[ub_offset],\\n data[data_offset],\\n 0, ori_nburst,\\n burst_len,\\n src_stride, dst_stride)\\n\\n else:\\n n_burst = 4095\\n c_cycle = ori_nburst // n_burst\\n c_mod = ori_nburst % n_burst\\n for num_cy in range(c_cycle):\\n data_cur = data_offset + (burst_len + src_stride)\\\\\\n * cp_align_len * n_burst * num_cy\\n ub_cur = ub_offset + (burst_len + dst_stride)\\\\\\n * cp_align_len * n_burst * num_cy\\n tik_instance.data_move(\\n data_ub[ub_cur],\\n data[data_cur],\\n 0, n_burst,\\n burst_len,\\n src_stride, dst_stride)\\n\\n if c_mod > 0:\\n data_cur = data_offset + (burst_len + src_stride)\\\\\\n * cp_align_len * n_burst * c_cycle\\n ub_cur = ub_offset + (burst_len + dst_stride)\\\\\\n * cp_align_len * n_burst * c_cycle\\n tik_instance.data_move(\\n data_ub[ub_cur],\\n data[data_cur],\\n 0, c_mod,\\n burst_len,\\n src_stride, dst_stride)\\n\\n else:\\n for num_nb in range(ori_nburst):\\n data_cur = data_offset + (burst_len + src_stride)\\\\\\n * cp_align_len * num_nb\\n ub_cur = ub_offset + (burst_len + dst_stride)\\\\\\n * cp_align_len * num_nb\\n tik_instance.data_move(\\n data_ub[ub_cur],\\n data[data_cur],\\n 0, 1,\\n burst_len,\\n 0, 0)\",\n \"def distort_vxs(self):\\n self.dvxs = self.vxs.copy()\\n self.dvxs[:, 0] += self.perlin()\\n self.dvxs[:, 1] += self.perlin()\",\n \"def update_E(self):\\n self.grid.E[:, 0, :, :] = self.grid.E[:, -1, :, :]\",\n \"def push_to_mem(self, batch_x, batch_y, t):\\n if self.real_epoch > 0:\\n return\\n\\n batch_x = batch_x.cpu()\\n batch_y = batch_y.cpu()\\n t = t.cpu()\\n\\n for i in range(batch_x.shape[0]):\\n self.age += 1\\n if len(self.M) < self.memories:\\n self.M.append([batch_x[i], batch_y[i], t])\\n else:\\n p = np.random.randint(0, self.age)\\n if p < self.memories:\\n self.M[p] = [batch_x[i], batch_y[i], t]\",\n \"def move_cloud(self):\\n self.remove()\\n self.min_x -= 1\\n self.max_x -= 1\\n self.update()\",\n \"def update(self, array) -> None:\\n this_device = self._current_device_index\\n\\n # clean up data\\n self._array._buffer = {n: None for n in range(num_gpu)}\\n self._array._buffer[CPU_INDEX] = None\\n\\n # copy new data to buffer\\n if isinstance(array, numpy.ndarray):\\n if this_device != CPU_INDEX: # CPU to GPU\\n self._array.set(this_device, cupy.asarray(array))\\n else: # data already in CPU\\n self._array.set(this_device, array)\\n else:\\n if this_device == CPU_INDEX: # GPU to CPU\\n self._array.set(this_device, cupy.asnumpy(array))\\n else: # GPU to GPU\\n if int(array.device) == this_device: # data already in this device\\n self._array.set(this_device, array)\\n else: # GPU to GPU\\n dst_data = cupy.empty_like(array)\\n dst_data.data.copy_from_device_async(array.data, array.nbytes)\\n self._array.set(this_device, dst_data)\\n\\n # update size\\n self.nbytes = array.nbytes\\n self.subarray_nbytes = self.nbytes\\n\\n self._slices = []\\n\\n # reset coherence\\n self._coherence.reset(this_device)\\n\\n # update shape\\n self._array.shape = array.shape\\n\\n if num_gpu > 0:\\n cupy.cuda.stream.get_current_stream().synchronize()\",\n \"def _move_in_one_more_block():\\n with tik_inst.for_range(0, sub_h_align_block_size) as sub_h_idx_0:\\n tik_inst.data_move(dst[sub_w_block * data_cnt_one_block * sub_h_idx_0],\\n src[in_offset + sub_h_idx_0 * w_size],\\n 0, 1, sub_w_block, 0, 0)\\n # move in one more block of h\\n with tik_inst.for_range(0, data_cnt_one_block) as sub_h_idx_1:\\n tik_inst.data_move(\\n dst[sub_w_block * data_cnt_one_block * (sub_h_align_block_size + sub_h_idx_1)],\\n src[in_offset + (sub_h_idx_1 + sub_h_size - data_cnt_one_block) * w_size],\\n 0, 1, sub_w_block, 0, 0)\",\n \"def precalculate(self):\\n self._sorted = np.argsort(\\n self.base[self._array], kind='mergesort') # mergesort for stability\\n self._boundaries = util.find_boundaries(\\n self.base[self._array][self._sorted])\",\n \"def test_nvcc_bug():\\r\\n shape = (5, 4)\\r\\n aa = theano._asarray(numpy.random.rand(*shape), dtype='float32')\\r\\n a = aa[::, ::-1]\\r\\n\\r\\n b = cuda_ndarray.CudaNdarray(aa)[::, ::-1]\\r\\n c = copy.copy(b)\\r\\n d = copy.deepcopy(b)\\r\\n\\r\\n assert numpy.allclose(a, numpy.asarray(b))\\r\\n assert numpy.allclose(a, numpy.asarray(c))\\r\\n assert numpy.allclose(a, numpy.asarray(d))\\r\\n b += b\\r\\n assert numpy.allclose(a+a, numpy.asarray(b))\\r\\n assert numpy.allclose(a+a, numpy.asarray(c))\\r\\n assert numpy.allclose(a, numpy.asarray(d))\",\n \"def global_to_local(npboxes: np.ndarray, window: Box):\\n xmin = window.xmin\\n ymin = window.ymin\\n return npboxes - np.array([[ymin, xmin, ymin, xmin]])\",\n \"def local_extrema_seuil(sweep, seuil1, seuil2, span) :\\n\\n #temporary elements\\n temp_min = 0\\n temp_min_arg = -1\\n temp_max = 0\\n temp_max_arg = -1\\n\\n #This holds the result\\n up_i = 0\\n down_i = 0\\n up = array([])\\n arg_up = array([])\\n down = array([])\\n arg_down = array([])\\n #init the writing bolean\\n min_write = True\\n max_write = True\\n sweep_size = size(sweep)\\n\\n for i in range(sweep_size) :\\n value = sweep[i]\\n #check if we are below the threshold, if yes, next point\\n if abs(value) < seuil1 :\\n max_write = True\\n min_write = True\\n if temp_max_arg != -1 :\\n #Reshape the array\\n s_up = array(shape(up))\\n s_up[0] = s_up[0] + 1\\n s_up = tuple(s_up)\\n up = resize(up,s_up)\\n arg_up = resize(arg_up,s_up)\\n #Assign values\\n up[up_i] = temp_max\\n arg_up[up_i] = temp_max_arg\\n up_i = up_i + 1\\n temp_max = 0\\n temp_max_arg = -1\\n\\n if temp_min_arg != -1 :\\n #Reshape the array\\n s_down = array(shape(down))\\n s_down[0] = s_down[0] + 1\\n s_down = tuple(s_down)\\n down = resize(down,s_down)\\n arg_down = resize(arg_down,s_down)\\n #Assign values\\n down[down_i] = temp_min\\n arg_down[down_i] = temp_min_arg\\n down_i = down_i + 1\\n temp_min = 0\\n temp_min_arg = -1\\n\\n continue\\n\\n\\n #if we are in beetween the two threshold\\n if abs(value) > seuil1 and abs(value) < seuil2 :\\n if value < temp_min and min_write :\\n temp_min = value\\n temp_min_arg = i\\n if value > temp_max and max_write:\\n temp_max = value\\n temp_max_arg = i\\n\\n #if we are above the threshold\\n if abs(value) > seuil2 :\\n #Make sure than min and max cannot be accessed before going back below seuil1\\n if value < - seuil2 :\\n min_write = False\\n if(temp_min_arg + span > i) :\\n temp_min = 0\\n temp_min_arg = -1\\n if value > seuil2 :\\n max_write = False\\n if(temp_max_arg + span > i) :\\n temp_max = 0\\n temp_max_arg = -1\\n\\n return [down, arg_down, up, arg_up]\",\n \"def test_nvcc_bug():\\n shape = (5, 4)\\n aa = theano._asarray(numpy.random.rand(*shape), dtype='float32')\\n a = aa[::, ::-1]\\n\\n b = cuda_ndarray.CudaNdarray(aa)[::, ::-1]\\n c = copy.copy(b)\\n d = copy.deepcopy(b)\\n\\n assert numpy.allclose(a, numpy.asarray(b))\\n assert numpy.allclose(a, numpy.asarray(c))\\n assert numpy.allclose(a, numpy.asarray(d))\\n b += b\\n assert numpy.allclose(a+a, numpy.asarray(b))\\n assert numpy.allclose(a+a, numpy.asarray(c))\\n assert numpy.allclose(a, numpy.asarray(d))\",\n \"def update_E(self):\\n self.grid.E[0, :, :, :] = self.grid.E[-1, :, :, :]\",\n \"def preprocess(self):\\n\\n mm_magcoord.add_aacgm_coordinates(self)\\n mm_magcoord.add_quasi_dipole_coordinates(self)\\n mm_sc.calculate_ecef_velocity(self)\\n mm_sc.add_ram_pointing_sc_attitude_vectors(self)\\n\\n return\",\n \"def _data_move_out_no_transpose(tik_inst, dst, src, data_pos_info):\\n data_size, out_offset, h_size, w_size = data_pos_info\\n data_one_block = _get_elment_cnt_one_block(src.dtype)\\n data_align_block = data_size // data_one_block\\n is_data_block_algin = data_size % data_one_block == 0\\n is_all_data_small_one_block = h_size * w_size < data_one_block\\n\\n with tik_inst.if_scope(is_data_block_algin):\\n tik_inst.data_move(dst[out_offset], src, 0, 1, data_align_block, 0, 0)\\n with tik_inst.else_scope():\\n with tik_inst.if_scope(is_all_data_small_one_block):\\n tik_inst.data_move(dst[out_offset], src, 0, 1, 1, 0, 0)\\n with tik_inst.else_scope():\\n tik_inst.data_move(dst[out_offset], src, 0, 1, data_align_block, 0, 0)\\n tik_inst.data_move(dst[out_offset + data_size - data_one_block],\\n src[data_align_block * data_one_block],\\n 0, 1, 1, 0, 0)\",\n \"def _setup_ndarrays(self) -> None:\\n empty = self.ele_orig * 0\\n # 2D arrays\\n self.ele = np.copy(self.ele_orig) # Elevation including glaciers\\n self.slp = np.copy(empty) # Slope with glacier geometry\\n self.asp = np.copy(empty) # Classified aspect with glacier geometry\\n self.h = np.copy(empty) # Local glacier height\\n self.u = np.copy(empty) # Local glacier velocity\\n self.hs = hillshade(\\n self.ele_orig,\\n self.PLOT_HILLSHADE_AZIMUTH,\\n self.PLOT_HILLSHADE_ALTITUDE,\\n ) # HS\\n\\n # Initialize array store\\n self.store = ArrayStore()\\n self.store.create(\\\"h\\\", self.MODEL_RECORD_SIZE)\\n self.store.create(\\\"u\\\", self.MODEL_RECORD_SIZE)\",\n \"def c_not_align_split_n_fp32(self, tik_instance):\\n n_d, d_d, h_d, w_d, c_d = self.dst_shape\\n dhw_d = d_d * h_d * w_d\\n nc_one = self.ub_ele // dhw_d\\n n_ub = nc_one // 2 // self.cp_align_len // c_d\\n\\n all_core = _ceil_div(n_d, n_ub)\\n ac_num = _set_core_num(all_core)\\n\\n with tik_instance.for_range(0, ac_num, block_num=ac_num) as num_core:\\n ub_ori = tik_instance.Tensor(\\\"float16\\\",\\n (self.ub_ele * 2,),\\n name=\\\"ub_ori\\\",\\n scope=tik.scope_ubuf)\\n ub_trans = tik_instance.Tensor(\\\"float16\\\",\\n (self.ub_ele * 2,),\\n name=\\\"ub_trans\\\",\\n scope=tik.scope_ubuf)\\n ub_tail = tik_instance.Tensor(\\\"float16\\\",\\n (16,),\\n name=\\\"ub_tail\\\",\\n scope=tik.scope_ubuf)\\n\\n ub_loop = _set_loop(tik_instance, num_core, ac_num, all_core)\\n\\n with tik_instance.for_range(0, ub_loop) as num_u:\\n core_index = num_u * ac_num + num_core\\n\\n with tik_instance.if_scope(core_index < all_core - 1):\\n n_len = n_ub\\n n_before = n_ub * core_index\\n args = tik_instance, ub_ori, ub_trans, ub_tail, \\\\\\n n_before, n_len\\n self.func_c_not_align_split_n_fp32(args)\\n\\n with tik_instance.else_scope():\\n n_before = (all_core - 1) * n_ub\\n n_len = n_d - n_before\\n args = tik_instance, ub_ori, ub_trans, ub_tail, \\\\\\n n_before, n_len\\n self.func_c_not_align_split_n_fp32(args)\\n\\n return tik_instance\",\n \"def backtransform_target(self, data):\\n # print(data)\\n # print(self.target_max)\\n #data = FloatTensor(data)\\n data *= self.target_max\\n data += self.target_min\\n return data # .numpy()\",\n \"def setupGPUStandard(solver):\\n #Correct GPU block\\n solver.gpuBlock = (slice(0,solver.sharedShape[0],1),)+solver.gpuBlock\\n solver.gpuReadBlock = solver.gpuBlock[:2]+tuple([slice(cs.start-solver.operating,cs.stop+solver.operating,1) for cs in solver.gpuBlock[2:]])\\n blockShape =[element.stop-element.start for element in solver.gpuBlock]\\n blockShape[-1] += int(2*solver.operating) #Adding 2 blocks in the column direction\\n blockShape[-2] += int(2*solver.operating) #Adding 2 blocks in the column direction\\n #Creating local GPU array with split\\n grid = (int((blockShape[2]-2*solver.operating)/solver.blocksize[0]),int((blockShape[3]-2*solver.operating)/solver.blocksize[1])) #Grid size\\n #Creating constants\\n bsp = lambda x: int(numpy.prod(blockShape[x:])) #block shape product returned as an integer\\n const_dict = ({\\\"NV\\\":blockShape[1],'SX':blockShape[2],'SY':blockShape[3],\\\"VARS\\\":bsp(2),\\\"TIMES\\\":bsp(1),\\\"OPS\\\":solver.operating,\\\"ITS\\\":solver.intermediate})\\n solver.GPUArray = mallocGPUArray(blockShape)\\n solver.localGPUArray = numpy.zeros(blockShape)\\n #Building CUDA source code\\n solver.gpu = io.buildGPUSource(solver.gpu)\\n io.copyConstants(solver.gpu,const_dict) #This copys gpu constants not global constants\\n solver.cpu.set_globals(*solver.globals,source_mod=solver.gpu)\\n #Make GPU geometry\\n solver.standard.initializeGPU(solver.gpu.get_function(\\\"Standard\\\"),solver.blocksize,grid)\",\n \"def test_op_sub_offload_array_float(self):\\n\\n device = pymic.devices[0]\\n stream = device.get_default_stream()\\n a = numpy.arange(1.0, 4711.0 * 1024, dtype=float)\\n o = a + 1.0\\n\\n old_a = numpy.empty_like(a)\\n old_o = numpy.empty_like(o)\\n old_a[:] = a[:]\\n old_o[:] = o[:]\\n expect = a - o\\n\\n offl_a = stream.bind(a)\\n offl_o = stream.bind(o)\\n offl_r = offl_a - offl_o\\n offl_a.update_host()\\n r = offl_r.update_host().array\\n stream.sync()\\n\\n self.assertEqual(r.shape, a.shape)\\n self.assertEqual(r.dtype, a.dtype)\\n self.assertTrue((a == old_a).all(),\\n \\\"Input array operand 1 must not be modified: \\\"\\n \\\"{0} should be {1}\\\".format(a, old_a))\\n self.assertTrue((o == old_o).all(),\\n \\\"Input array operand 2 must not be modified: \\\"\\n \\\"{0} should be {1}\\\".format(o, old_o))\\n self.assertTrue((r == expect).all(),\\n \\\"Array contains unexpected values: \\\"\\n \\\"{0} should be {1}\\\".format(r, expect))\",\n \"def update_E(self):\\n self.grid.E[:, :, 0, :] = self.grid.E[:, :, -1, :]\",\n \"def place_targets():\\n\\n \\n coords = []\\n while len(coords)<self.N_targets:\\n x = np.random.randint(self.BORDER_MARGIN,self.map_dimensions[1]+1-self.BORDER_MARGIN,size=1)[0]\\n y = np.random.randint(self.BORDER_MARGIN,self.map_dimensions[0]+1-self.BORDER_MARGIN,size=1)[0]\\n p = (x,y)\\n all_valid = True\\n for rect in self.coordinates__obstacles:\\n if not check_valid_placement(p,rect):\\n all_valid = False\\n break\\n if all_valid:\\n coords +=[p]\\n self.coordinates__targets = coords\",\n \"def move(self):\\n \\\"\\\"\\\" Responsible for transformations \\\"\\\"\\\"\\n pos, com, success = self.perception \\n if self.destination is None:\\n return array([0,0])\\n\\n if not self.awake:\\n return array([0,0])\\n\\n\\n if self.phase == 4 and self.proper_formation is not None:\\n no_go = []\\n for i in range(0,len(self.proper_formation)):\\n if i != self.order and self.proper_formation[i][0] == self.proper_formation[self.order][0]:\\n no_go.append(self.transform(self.proper_formation[i][1] - self.position))\\n pos = merge_array_lists(pos, no_go)\\n\\n if self.phase == 2:\\n point = self.destination.copy() - self.position\\n elif self.phase > 2:\\n point = self.transform(self.destination.copy() - self.position)\\n else:\\n point = self.destination.copy()\\n\\n if not array_equal(point, array([0,0])):\\n reachable, path = findpathtoclosest(array([0,0]), point, pos)\\n \\n if len(path) == 0:\\n move = array([0,0]) \\n else:\\n move = path[0]\\n if not reachable and not array_equal(move,array([0,0])):\\n if self.phase == 2:\\n self.closest_i_could_get = path[-1] + self.position\\n elif self.phase > 2:\\n self.closest_i_could_get = self.transform2(path[-1]) + self.position\\n else:\\n self.closest_i_could_get = path[-1]\\n elif not reachable:\\n if self.phase > 1:\\n self.closest_i_could_get = self.position\\n else:\\n self.closest_i_could_get = array([0,0])\\n else:\\n self.closest_i_could_get = None\\n\\n if reachable and self.phase == 4 and array_equal(move,array([0,0])):\\n move = self.randomStep()\\n self.closest_i_could_get = None\\n\\n else:\\n move = array([0,0])\\n self.closest_i_could_get = None\\n\\n return move\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5812451","0.5725411","0.5472441","0.545434","0.54450196","0.54422855","0.5420267","0.53995526","0.5396849","0.53827024","0.5343788","0.53435355","0.5315347","0.5311603","0.52795476","0.52631","0.5237792","0.52351785","0.5228774","0.5220994","0.5220994","0.52097064","0.5197336","0.51362026","0.51292306","0.5112534","0.5106714","0.51046485","0.5098579","0.5080496","0.5077528","0.50591373","0.50565374","0.5055612","0.50527775","0.5052277","0.5047226","0.5044257","0.5042461","0.50370646","0.5030179","0.50281084","0.5007509","0.50041515","0.49986428","0.49970838","0.4996992","0.49930483","0.4989488","0.49873886","0.4983849","0.4983734","0.4981551","0.49756953","0.497514","0.49744013","0.49604905","0.49600568","0.49598423","0.49429178","0.49429178","0.49429178","0.49429178","0.49429178","0.49429178","0.49429178","0.49429178","0.49429178","0.49429178","0.49429178","0.49369398","0.4930031","0.49296638","0.49227205","0.49176756","0.49131724","0.49121734","0.49085245","0.49026096","0.4893763","0.48917335","0.48902345","0.48887852","0.48835868","0.48827356","0.48822737","0.48753297","0.48647976","0.48623663","0.48581156","0.4856934","0.48554483","0.48507994","0.48418158","0.48408243","0.48402157","0.48355234","0.4832261","0.48318714","0.48278064"],"string":"[\n \"0.5812451\",\n \"0.5725411\",\n \"0.5472441\",\n \"0.545434\",\n \"0.54450196\",\n \"0.54422855\",\n \"0.5420267\",\n \"0.53995526\",\n \"0.5396849\",\n \"0.53827024\",\n \"0.5343788\",\n \"0.53435355\",\n \"0.5315347\",\n \"0.5311603\",\n \"0.52795476\",\n \"0.52631\",\n \"0.5237792\",\n \"0.52351785\",\n \"0.5228774\",\n \"0.5220994\",\n \"0.5220994\",\n \"0.52097064\",\n \"0.5197336\",\n \"0.51362026\",\n \"0.51292306\",\n \"0.5112534\",\n \"0.5106714\",\n \"0.51046485\",\n \"0.5098579\",\n \"0.5080496\",\n \"0.5077528\",\n \"0.50591373\",\n \"0.50565374\",\n \"0.5055612\",\n \"0.50527775\",\n \"0.5052277\",\n \"0.5047226\",\n \"0.5044257\",\n \"0.5042461\",\n \"0.50370646\",\n \"0.5030179\",\n \"0.50281084\",\n \"0.5007509\",\n \"0.50041515\",\n \"0.49986428\",\n \"0.49970838\",\n \"0.4996992\",\n \"0.49930483\",\n \"0.4989488\",\n \"0.49873886\",\n \"0.4983849\",\n \"0.4983734\",\n \"0.4981551\",\n \"0.49756953\",\n \"0.497514\",\n \"0.49744013\",\n \"0.49604905\",\n \"0.49600568\",\n \"0.49598423\",\n \"0.49429178\",\n \"0.49429178\",\n \"0.49429178\",\n \"0.49429178\",\n \"0.49429178\",\n \"0.49429178\",\n \"0.49429178\",\n \"0.49429178\",\n \"0.49429178\",\n \"0.49429178\",\n \"0.49429178\",\n \"0.49369398\",\n \"0.4930031\",\n \"0.49296638\",\n \"0.49227205\",\n \"0.49176756\",\n \"0.49131724\",\n \"0.49121734\",\n \"0.49085245\",\n \"0.49026096\",\n \"0.4893763\",\n \"0.48917335\",\n \"0.48902345\",\n \"0.48887852\",\n \"0.48835868\",\n \"0.48827356\",\n \"0.48822737\",\n \"0.48753297\",\n \"0.48647976\",\n \"0.48623663\",\n \"0.48581156\",\n \"0.4856934\",\n \"0.48554483\",\n \"0.48507994\",\n \"0.48418158\",\n \"0.48408243\",\n \"0.48402157\",\n \"0.48355234\",\n \"0.4832261\",\n \"0.48318714\",\n \"0.48278064\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6041597"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":87192,"cells":{"query":{"kind":"string","value":"Compute the indices that are needed (symmertic velocities and space indices)."},"document":{"kind":"string","value":"def set_iload(self):\n k = self.istore[0]\n ksym = self.stencil.get_symmetric()[k][np.newaxis, :]\n v = self.stencil.get_all_velocities()\n indices = self.istore[1:] + v[k].T\n self.iload.append(np.concatenate([ksym, indices]))"},"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 indices_and_currents_TSC_2D( charge_electron, positions_x, positions_y, velocity_x, velocity_y,\\\n x_grid, y_grid, ghost_cells, length_domain_x, length_domain_y, dt ):\n \n \n positions_x_new = positions_x + velocity_x * dt\n positions_y_new = positions_y + velocity_y * dt\n\n base_indices_x = af.data.constant(0, positions_x.elements(), dtype=af.Dtype.u32)\n base_indices_y = af.data.constant(0, positions_x.elements(), dtype=af.Dtype.u32)\n\n dx = af.sum(x_grid[1] - x_grid[0])\n dy = af.sum(y_grid[1] - y_grid[0])\n\n\n # Computing S0_x and S0_y\n ###########################################################################################\n \n # Determining the grid cells containing the respective particles\n \n x_zone = (((af.abs(positions_x - af.sum(x_grid[0])))/dx).as_type(af.Dtype.u32))\n y_zone = (((af.abs(positions_y - af.sum(y_grid[0])))/dy).as_type(af.Dtype.u32))\n\n \n # Determing the indices of the closest grid node in x direction\n\n temp = af.where(af.abs(positions_x-x_grid[x_zone]) < \\\n af.abs(positions_x-x_grid[x_zone + 1])\\\n )\n\n if(temp.elements()>0):\n base_indices_x[temp] = x_zone[temp]\n\n temp = af.where(af.abs(positions_x - x_grid[x_zone]) >= \\\n af.abs(positions_x-x_grid[x_zone + 1])\\\n )\n\n if(temp.elements()>0):\n base_indices_x[temp] = (x_zone[temp] + 1).as_type(af.Dtype.u32) \n\n\n # Determing the indices of the closest grid node in y direction\n\n temp = af.where(af.abs(positions_y-y_grid[y_zone]) < \\\n af.abs(positions_y-y_grid[y_zone + 1])\\\n )\n\n if(temp.elements()>0):\n base_indices_y[temp] = y_zone[temp]\n\n temp = af.where(af.abs(positions_y - y_grid[y_zone])>=af.abs(positions_y-x_grid[y_zone + 1]))\n\n if(temp.elements()>0):\n base_indices_y[temp] = (y_zone[temp] + 1).as_type(af.Dtype.u32) \n\n # Concatenating the index list for near by grid nodes in x direction\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\n\n base_indices_minus_two = (base_indices_x - 2).as_type(af.Dtype.u32) \n base_indices_minus = (base_indices_x - 1).as_type(af.Dtype.u32) \n base_indices_plus = (base_indices_x + 1).as_type(af.Dtype.u32) \n base_indices_plus_two = (base_indices_x + 2).as_type(af.Dtype.u32) \n\n\n\n index_list_x = af.join( 1,\\\n af.join(1, base_indices_minus_two, base_indices_minus, base_indices_x),\\\n af.join(1, base_indices_plus, base_indices_plus_two),\\\n )\n\n\n\n # Concatenating the index list for near by grid nodes in y direction\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\n \n base_indices_minus_two = (base_indices_y - 2).as_type(af.Dtype.u32) \n base_indices_minus = (base_indices_y - 1).as_type(af.Dtype.u32) \n base_indices_plus = (base_indices_y + 1).as_type(af.Dtype.u32) \n base_indices_plus_two = (base_indices_y + 2).as_type(af.Dtype.u32) \n\n\n index_list_y = af.join( 1,\\\n af.join(1, base_indices_minus_two, base_indices_minus, base_indices_y),\\\n af.join(1, base_indices_plus, base_indices_plus_two),\\\n )\n\n # Concatenating the positions_x for determining weights for near by grid nodes in y direction\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\n\n positions_x_5x = af.join( 0,\\\n af.join(0, positions_x, positions_x, positions_x),\\\n af.join(0, positions_x, positions_x),\\\n )\n\n positions_y_5x = af.join( 0,\\\n af.join(0, positions_y, positions_y, positions_y),\\\n af.join(0, positions_y, positions_y),\\\n )\n\n\n\n\n # Determining S0 for positions at t = n * dt\n\n\n distance_nodes_x = x_grid[af.flat(index_list_x)]\n\n distance_nodes_y = y_grid[af.flat(index_list_y)]\n\n\n W_x = 0 * distance_nodes_x.copy()\n W_y = 0 * distance_nodes_y.copy()\n\n\n # Determining weights in x direction\n\n temp = af.where(af.abs(distance_nodes_x - positions_x_5x) < (0.5*dx) )\n\n if(temp.elements()>0):\n W_x[temp] = 0.75 - (af.abs(distance_nodes_x[temp] - positions_x_5x[temp])/dx)**2\n\n temp = af.where((af.abs(distance_nodes_x - positions_x_5x) >= (0.5*dx) )\\\n * (af.abs(distance_nodes_x - positions_x_5x) < (1.5 * dx) )\\\n )\n\n if(temp.elements()>0):\n W_x[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_x[temp] - positions_x_5x[temp])/dx))**2\n\n\n\n # Determining weights in y direction\n\n temp = af.where(af.abs(distance_nodes_y - positions_y_5x) < (0.5*dy) )\n\n if(temp.elements()>0):\n W_y[temp] = 0.75 - (af.abs(distance_nodes_y[temp] - positions_y_5x[temp])/dy)**2\n\n temp = af.where((af.abs(distance_nodes_y - positions_y_5x) >= (0.5*dy) )\\\n * (af.abs(distance_nodes_y - positions_y_5x) < (1.5 * dy) )\\\n )\n\n if(temp.elements()>0):\n W_y[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_y[temp] - positions_y_5x[temp])/dy))**2\n\n # Restructering W_x and W_y for visualization and ease of understanding\n\n W_x = af.data.moddims(W_x, positions_x.elements(), 5)\n W_y = af.data.moddims(W_y, positions_y.elements(), 5)\n\n # Tiling the S0_x and S0_y for the 25 indices around the particle\n \n S0_x = af.tile(W_x, 1, 1, 5)\n S0_y = af.tile(W_y, 1, 1, 5)\n\n\n S0_y = af.reorder(S0_y, 0, 2, 1)\n\n\n\n #Computing S1_x and S1_y\n ###########################################################################################\n\n positions_x_5x_new = af.join( 0,\\\n af.join(0, positions_x_new, positions_x_new, positions_x_new),\\\n af.join(0, positions_x_new, positions_x_new),\\\n )\n\n positions_y_5x_new = af.join( 0,\\\n af.join(0, positions_y_new, positions_y_new, positions_y_new),\\\n af.join(0, positions_y_new, positions_y_new),\\\n )\n\n\n\n\n # Determining S0 for positions at t = n * dt\n\n W_x = 0 * distance_nodes_x.copy()\n W_y = 0 * distance_nodes_y.copy()\n\n\n # Determining weights in x direction\n\n temp = af.where(af.abs(distance_nodes_x - positions_x_5x_new) < (0.5*dx) )\n\n if(temp.elements()>0):\n W_x[temp] = 0.75 - (af.abs(distance_nodes_x[temp] - positions_x_5x_new[temp])/dx)**2\n\n temp = af.where((af.abs(distance_nodes_x - positions_x_5x_new) >= (0.5*dx) )\\\n * (af.abs(distance_nodes_x - positions_x_5x_new) < (1.5 * dx) )\\\n )\n\n if(temp.elements()>0):\n W_x[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_x[temp] \\\n - positions_x_5x_new[temp])/dx\\\n )\\\n )**2\n\n\n\n # Determining weights in y direction\n\n temp = af.where(af.abs(distance_nodes_y - positions_y_5x_new) < (0.5*dy) )\n\n if(temp.elements()>0):\n W_y[temp] = 0.75 - (af.abs(distance_nodes_y[temp] \\\n - positions_y_5x_new[temp]\\\n )/dy\\\n )**2\n\n temp = af.where((af.abs(distance_nodes_y - positions_y_5x_new) >= (0.5*dy) )\\\n * (af.abs(distance_nodes_y - positions_y_5x_new) < (1.5 * dy) )\\\n )\n\n if(temp.elements()>0):\n W_y[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_y[temp] \\\n - positions_y_5x_new[temp])/dy\\\n )\\\n )**2\n\n # Restructering W_x and W_y for visualization and ease of understanding\n\n W_x = af.data.moddims(W_x, positions_x.elements(), 5)\n W_y = af.data.moddims(W_y, positions_x.elements(), 5)\n\n # Tiling the S0_x and S0_y for the 25 indices around the particle \n \n S1_x = af.tile(W_x, 1, 1, 5)\n S1_y = af.tile(W_y, 1, 1, 5)\n\n S1_y = af.reorder(S1_y, 0, 2, 1)\n\n\n ###########################################################################################\n\n # Determining the final weight matrix for currents in 3D matrix form factor\n\n\n W_x = (S1_x - S0_x) * (S0_y + (0.5 *(S1_y - S0_y)) )\n\n\n W_y = (S1_y - S0_y) * (S0_x + (0.5 *(S1_x - S0_x)) )\n\n\n ###########################################################################################\n\n\n # Assigning Jx and Jy according to Esirkepov's scheme\n\n Jx = af.data.constant(0, positions_x.elements(), 5, 5, dtype = af.Dtype.f64)\n Jy = af.data.constant(0, positions_x.elements(), 5, 5, dtype = af.Dtype.f64)\n\n\n Jx[:, 0, :] = -1 * charge_electron * (dx/dt) * W_x[:, 0, :].copy()\n Jx[:, 1, :] = Jx[:, 0, :] + -1 * charge_electron * (dx/dt) * W_x[:, 1, :].copy()\n Jx[:, 2, :] = Jx[:, 1, :] + -1 * charge_electron * (dx/dt) * W_x[:, 2, :].copy()\n Jx[:, 3, :] = Jx[:, 2, :] + -1 * charge_electron * (dx/dt) * W_x[:, 3, :].copy()\n Jx[:, 4, :] = Jx[:, 3, :] + -1 * charge_electron * (dx/dt) * W_x[:, 4, :].copy()\n \n # Computing current density using currents\n \n Jx = (1/(dx * dy)) * Jx\n\n\n Jy[:, :, 0] = -1 * charge_electron * (dy/dt) * W_y[:, :, 0].copy()\n Jy[:, :, 1] = Jy[:, :, 0] + -1 * charge_electron * (dy/dt) * W_y[:, :, 1].copy()\n Jy[:, :, 2] = Jy[:, :, 1] + -1 * charge_electron * (dy/dt) * W_y[:, :, 2].copy()\n Jy[:, :, 3] = Jy[:, :, 2] + -1 * charge_electron * (dy/dt) * W_y[:, :, 3].copy()\n Jy[:, :, 4] = Jy[:, :, 3] + -1 * charge_electron * (dy/dt) * W_y[:, :, 4].copy()\n \n # Computing current density using currents\n\n Jy = (1/(dx * dy)) * Jy\n\n # Preparing the final index and current vectors\n ###########################################################################################\n \n \n # Determining the x indices for charge deposition\n index_list_x_Jx = af.flat(af.tile(index_list_x, 1, 1, 5))\n\n # Determining the y indices for charge deposition\n y_current_zone = af.tile(index_list_y, 1, 1, 5)\n index_list_y_Jx = af.flat(af.reorder(y_current_zone, 0, 2, 1))\n\n\n currents_Jx = af.flat(Jx)\n\n # Determining the x indices for charge deposition\n index_list_x_Jy = af.flat(af.tile(index_list_x, 1, 1, 5))\n\n # Determining the y indices for charge deposition\n y_current_zone = af.tile(index_list_y, 1, 1, 5)\n index_list_y_Jy = af.flat(af.reorder(y_current_zone, 0, 2, 1))\n \n # Flattenning the Currents array\n currents_Jy = af.flat(Jy)\n\n af.eval(index_list_x_Jx, index_list_y_Jx)\n af.eval(index_list_x_Jy, index_list_y_Jy)\n af.eval(currents_Jx, currents_Jy)\n\n\n return index_list_x_Jx, index_list_y_Jx, currents_Jx,\\\n index_list_x_Jy, index_list_y_Jy, currents_Jy","def generate_index(self):\n begin_o, end_o, begin_a, end_a = 0, 0, 0, 0\n for obs_space, act_space in zip(self.env.observation_space, self.env.action_space):\n end_o = end_o + obs_space.shape[0]\n if isinstance(act_space, Box):\n end_a = act_space.shape[0]\n else:\n end_a = act_space.n\n range_o = (begin_o, end_o)\n range_a = (begin_a, end_a)\n self.observation_index.append(range_o)\n self.action_index.append(range_a)\n begin_o = end_o\n begin_a = end_a","def mesh_span_indices(self):\n self._ensure_mesh()\n k2m = self._knots_to_mesh\n return np.where(k2m[1:] != k2m[:-1])[0]","def get_index(self, x, y):\n i = (y - self.y0) // self.dy\n j = (x - self.x0) // self.dx\n i = min(max(i, 0), self.n-1)\n j = min(max(j, 0), self.m-1)\n return [i, j]","def calculate_esi_index(radius, mass, temperature):\n density = Calculator.calculate_average_density(radius, mass)\n escape_velocity = Calculator.calculate_escape_velocity(radius, mass)\n\n factors = [\n (radius, 6.3781e6, 0.57/4),\n (density, 5513, 1.07/4),\n (escape_velocity, 11200, 0.70/4),\n (temperature, 288, 5.58/4)\n ]\n res = [(1 - abs(x - y)/abs(x + y)) ** z for x, y, z in factors]\n return functools.reduce(operator.mul, res)","def mainIndices(self):\n return self.i1, self.i2","def get_indices(self):\r\n return self._indices","def indices(self) -> np.ndarray:\n return self.impl.indices","def __build_state_index(self):\n\n # the index for the system state\n # [rho_i, q_in, q_out, r_i, f_i]\n x_index = {}\n\n # add the density index\n x_index['density'] = OrderedDict()\n for i in range(0, self.num_cells):\n x_index['density'][i] = i\n dim_state = self.num_cells\n\n # add the upstream boundary flow\n x_index['qin'] = dim_state\n x_index['qout'] = dim_state + 1\n dim_state += 2\n\n # add on ramp variables\n # x_index['onramp'] = OrderedDict()\n # if self.cell_onramp is not None:\n # # if onramp exist in the network, otherwise skip\n # for cell_id in self.cell_onramp:\n # # add the absolute index into the state index dictionary\n # # r_i index = self.x_index{'onramp'][cell_i]\n # x_index['onramp'][cell_id] = dim_state\n # dim_state += 1\n #\n #\n # # add off ramp state variables\n # x_index['offramp'] = OrderedDict()\n # if self.cell_offramp is not None:\n # for cell_id in self.cell_offramp:\n # # add the absolute index\n # x_index['offramp'][cell_id] = dim_state\n # dim_state += 1\n\n return x_index, dim_state","def indices(self):\n _indices = []\n for h in self.miller.indices():\n _indices.append(self.indices_hkl(*h)[0])\n return _indices","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 get_index(self):\n return (np.sqrt(self.dielectric))","def create_elastic_indices():\n # initial values\n alpha, alpha2, sigma = 10, 10, 50\n shape = (96, 288) # same as shape of input images\n x_mesh, y_mesh = np.meshgrid(np.arange(shape[1]), np.arange(shape[0]))\n\n # below is used once per epoch for the elastic deformation\n g_1d = signal.gaussian(300, sigma)\n kernel_deform = np.outer(g_1d, g_1d)\n dx = signal.fftconvolve(np.random.rand(*shape) * 2 - 1, kernel_deform, mode='same')\n dy = signal.fftconvolve(np.random.rand(*shape) * 2 - 1, kernel_deform, mode='same')\n dx = alpha * (dx - np.mean(dx)) / np.std(dx)\n dy = alpha2 * (dy - np.mean(dy)) / np.std(dy)\n indices_x, indices_y = x_mesh + dx, y_mesh + dy\n indices_x_clipped = np.clip(indices_x, a_min=0, a_max=shape[1] - 1)\n indices_y_clipped = np.clip(indices_y, a_min=0, a_max=shape[0] - 1)\n return indices_x_clipped, indices_y_clipped","def get_idx(velocity, coord):\n d = velocity.node_intervals\n dx=d[0]\n dz=d[1]\n dy=d[2]\n mn = velocity.min_coords\n mnx=mn[0]\n mnz=mn[1]\n mny=mn[2]\n ix = int((coord[0] - mnx)/dx)\n iz = int((coord[1] - mnz)/dz)\n iy = int((coord[2] - mny)/dy)\n return (ix, iz, iy)","def _get_k_indices(self, ks):\n if self.staticneighs:\n idx_ks = ks\n else:\n idx_ks = [self.ks.index(e) for e in ks]\n return idx_ks","def indices(self):\n return self.index.indices","def get_analytical_velocities(self):\n # create empty numpy array for accelerations\n velocities = np.zeros((3, len(self.times)))\n # tangential velocity is angular velocity multiplied by radius but radius is one\n vt = self.wz\n # decompose tangential velocity in x and y components\n velocities[0, :] = vt * -sin(self.th[:, 2])\n velocities[1, :] = vt * cos(self.th[:, 2])\n # linear velocity along z axis\n velocities[2, :] = self.v0x + self.ax * self.times\n return velocities","def getIndices(self):\r\n return self._indices","def Indexes(self, latitudes, longitudes):\n res = self._transform.TransformPoints(\n np.column_stack((longitudes, latitudes)))\n res = list(zip(*res))\n x, y = np.array(res[0]), np.array(res[1])\n idx_col = self._inv_txf[0] + self._inv_txf[1] * x + self._inv_txf[2] * y\n idx_row = self._inv_txf[3] + self._inv_txf[4] * x + self._inv_txf[5] * y\n return idx_row.astype(int), idx_col.astype(int)","def indices(self):\n i, j, _edge = self.indicesAndEdge()\n return i, j","def update_idx(self):\n self.idx = (self.F * self.FMUL +\n self.E * self.EMUL +\n self.Z * self.ZMUL +\n self.A * self.AMUL +\n self.B * self.BMUL )","def vir_indices(self):\n indices = []\n for index,item in enumerate(self):\n if item==0:\n indices.append(index)\n return indices","def master_ndindex(self): # itermaster_indices(self):\n return itertools_product(\n *[range(*r) for r in self.location]\n ) # TODO check","def coord_indices_of(self, v_list):\n return [self.coord_index_of(v) for v in v_list]","def efficient_integer_vectors(self):\n return self._efficient_integer_vectors","def test_get_indices_several_existing_items(self):\r\n control_ids = ['PC.354', 'PC.355', 'PC.356', 'PC.481', 'PC.593']\r\n exp_control_indices = [0, 1, 2, 3, 4]\r\n\r\n fast_ids = ['PC.607', 'PC.634', 'PC.635', 'PC.636']\r\n exp_fast_indices = [5, 6, 7, 8]\r\n\r\n obs_control = _get_indices(self.dist_matrix_header, control_ids)\r\n self.assertEqual(obs_control, exp_control_indices)\r\n\r\n obs_fast = _get_indices(self.dist_matrix_header, fast_ids)\r\n self.assertEqual(obs_fast, exp_fast_indices)","def _state_index(state):\n delta_y, delta_x, bird_lmh, pipe_lmh, is_flapping = state\n actions, height, width, _, _, _ = Q.shape\n\n y = int((height / 2) + (delta_y / step_r) - 1)\n x = int((width / 2) + (delta_x / step_c) - 1)\n\n return y, x, bird_lmh, pipe_lmh, is_flapping","def get_analytically_computed_optimization_parameter_indices(self):\n indices = []\n if '/offsetParameterIndices' in self.f:\n indices.extend(self.f['/offsetParameterIndices'])\n\n if '/scalingParameterIndices' in self.f:\n indices.extend(self.f['/scalingParameterIndices'])\n\n if '/sigmaParameterIndices' in self.f:\n indices.extend(self.f['/sigmaParameterIndices'])\n\n return list(set(indices))","def calc_target_index(self, state, cx, cy):\n # Calc front axle position\n fx = state.x + self.L * np.cos(state.yaw) / 2.0\n fy = state.y + self.L * np.sin(state.yaw) / 2.0\n\n # Search nearest point index\n dx = []\n dy = []\n\n i = 0\n for icx in cx:\n if i < self.ind - 1000:\n dx.append(float(\"inf\"))\n else:\n dx.append(fx - icx)\n i += 1\n\n i = 0\n for icy in cy:\n if i < self.ind - 1000:\n dy.append(float(\"inf\"))\n else:\n dy.append(fy - icy)\n i += 1\n\n # dx = [fx - icx for icx in cx]\n # dy = [fy - icy for icy in cy]\n\n d = np.hypot(dx, dy)\n target_idx = np.argmin(d)\n\n # Project RMS error onto front axle vector\n front_axle_vec = [-np.cos(state.yaw + np.pi / 2), -\n np.sin(state.yaw + np.pi / 2)]\n\n error_front_axle = np.dot(\n [dx[target_idx], dy[target_idx]], front_axle_vec)\n\n\n\n return target_idx, error_front_axle","def calculate_index_and_derivative(wl):\n index = np.sqrt(1 + (0.6961663 * wl * wl) / (wl * wl - 0.0684043 * 0.0684043)\n + (0.4079426 * wl * wl) / (wl * wl - 0.1162414 * 0.1162414)\n + (0.8974794 * wl * wl) / (wl * wl - 9.896161 * 9.896161)\n )\n\n index_derivative = \\\n (\n - (1.79496 * wl * wl * wl) / (pow(-97.934 + wl * wl, 2))\n + (1.79496 * wl) / (-97.934 + wl * wl)\n\n - (0.815885 * wl * wl * wl) / (pow(-0.0135121 + wl * wl, 2))\n + (0.815885 * wl) / (-0.0135121 + wl * wl)\n\n - (1.39233 * wl * wl * wl) / (pow(-0.00467915 + wl * wl, 2))\n + (1.39233 * wl) / (-0.00467915 + wl * wl)\n ) \\\n / \\\n (2 * np.sqrt(\n 1\n + (0.897479 * wl * wl) / (-97.934 + wl * wl)\n + (0.407943 * wl * wl) / (-0.0135121 + wl * wl)\n + (0.696166 * wl * wl) / (-0.00467915 + wl * wl)\n )\n )\n return index, index_derivative","def indices(self):\n return range(len(self))","def get_local_indices(self, part, ctx):\n return self.map_to_global(\n F.arange(0, self.local_size(part), ctx=ctx), part\n )","def damping_index(self):\n start_index = self.kp_index[1]\n end_index = start_index + self.control_dim\n\n if self.impedance_flag:\n return (start_index, end_index)\n else:\n return None","def comp_amplification_index(self):\n \n self.grid_tuning_in=self.inputs.grid_tuning_in\n self.grid_tuning_out=gl.comp_grid_tuning_index(self.L,self.nx,(self.r[0:self.n_e**2,:]).T) \n self.grid_tuning_out_inhib=gl.comp_grid_tuning_index(self.L,self.nx,(self.r[self.n_e**2:,:]).T)\n\n self.grid_amp_index=self.grid_tuning_out/self.grid_tuning_in","def compute_tides(self):\r\n # take the period of the asteroid rotation\r\n P = self.period\r\n\r\n # compute the angle of the asteroid\r\n phase = 2*np.pi*(float(self.t) % P)/P\r\n\r\n # get points\r\n points = self.V.tabulate_dof_coordinates()[::3]\r\n\r\n # rotate points to the position they should be in, in the solar frame\r\n points = self.rotate_points(points, -phase)\r\n\r\n # get the acceleration, multiplies by rho\r\n force = float(self.rho)*self.tidal_acc(points)\r\n\r\n # rotate the force back to the actual points\r\n force = self.rotate_points(force, phase)\r\n\r\n # update the force function from the array\r\n self.ftides.vector()[:] = force.flatten()","def get_vacancy_indices(array):\t\n\tvacancy_indices = np.argwhere(array == 0)\n\treturn vacancy_indices","def _get_indexes(self, participants):\n tr_idx = int(np.floor(self.tr_size*len(participants)))\n j = self.val_size + self.tr_size\n val_idx = int(np.floor(j*len(participants)))\n return tr_idx, val_idx","def indices(self):\n return self._kbounded_partitions","def build_amg_index_sets(L_sizes):\n neqns = L_sizes[0][0]\n velocityDOF=[]\n for start in range(1,3):\n velocityDOF.append(np.arange(start=start,\n stop=1+neqns,\n step=3,\n dtype='i'))\n velocityDOF_full=np.vstack(velocityDOF).transpose().flatten()\n velocity_u_DOF = []\n velocity_u_DOF.append(np.arange(start=0,\n stop=2*neqns//3,\n step=2,\n dtype='i'))\n velocity_u_DOF_full = np.vstack(velocity_u_DOF).transpose().flatten()\n velocity_v_DOF = []\n velocity_v_DOF.append(np.arange(start=1,\n stop=1+2*neqns//3,\n step=2,\n dtype='i'))\n velocity_v_DOF_full = np.vstack(velocity_v_DOF).transpose().flatten()\n isvelocity = PETSc.IS()\n isvelocity.createGeneral(velocityDOF_full)\n isu = PETSc.IS()\n isu.createGeneral(velocity_u_DOF_full)\n isv = PETSc.IS()\n isv.createGeneral(velocity_v_DOF_full)\n return [isvelocity, isu, isv]","def two_dim_index(self, k):\n ind_x = k % self.nx\n ind_y = (k - ind_x) / self.nx\n return (int(ind_y), int(ind_x))","def csm_indices(csm):\r\n return csm_properties(csm)[1]","def getGlobalIdxVals( self, i : int ):\n return range(self._layout.starts[i],self._layout.ends[i])","def get_param_indexes(self):\n self.debug.start_function('get_param_indexes')\n\n for i, key in enumerate(self.mcmc_version.param_keys):\n self.param_idxs[key] = i\n for i, key in enumerate(self.mcmc_version.interp_keys):\n self.interp_idxs[key] = i\n\n self.debug.end_function()","def vector(self,\n i: int,\n j: int) -> np.ndarray:\n return self[j].coord - self[i].coord","def jw_number_indices(n_electrons, n_qubits):\n occupations = itertools.combinations(range(n_qubits), n_electrons)\n indices = [sum([2**n for n in occupation]) for occupation in occupations]\n return indices","def _compute_indices(self):\n self.indices = np.arange(len(self.im_filenames))\n np.random.shuffle(self.indices)","def computeIndices(org_center:tuple, rot_center:tuple, xyPairs, angle, org_box_offset:tuple):\n rot_center = np.array([[rot_center[0]], [rot_center[1]]])\n org_center = np.array([[org_center[0]], [org_center[1]]])\n org_box_offset = np.array([[org_box_offset[0]], [org_box_offset[1]]])\n newPairs = xyPairs - rot_center\n\n rotMatrix = buildRotationMatrix(angle)\n\n orgPairs = np.matmul(rotMatrix, newPairs)\n\n return np.array(orgPairs) + org_center + org_box_offset","def indices(self, position=None):\n \n raise NotImplementedError()","def ets(self):\n r = (self.table[0, 0] + self.table[0, 1]) * (self.table[0, 0] + self.table[1, 0]) / self.N\n return (self.table[0, 0] - r) / (self.table[0, 0] + self.table[0, 1] + self.table[1, 0] - r)","def _get_permutated_segments_indices(\n self, randomized: bool, random_state: Optional[np.random.mtrand.RandomState]\n ) -> np.ndarray:\n idx = np.arange(self.dy.size)\n\n if randomized:\n if random_state is None:\n random_state = np.random.RandomState()\n idx = random_state.permutation(idx)\n return idx","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 indices ( self, x1, y1, z1, x2, y2, z2 ):\n xi1, yi1, zi1 = self.index(min(x1, x2), min(y1, y2), min(z1, z2))\n xi2, yi2, zi2 = self.index(max(x1, x2), max(y1, y2), max(z1, z2))\n return s_[xi1:xi2+1], s_[yi1:yi2+1], s_[zi1:zi2+1]","def surface_indices(self):\n return self._unique_surface_indices(self.surf_mesh)","def getVectors(self):\n vectors = dict()\n i = 0\n N = len(self.db.invertedIndex)\n for w, (idf, docs) in self.db.invertedIndex.items():\n for doc, tf in docs.items():\n try:\n vectors[doc][i] = tf * idf\n except KeyError as k:\n vectors[doc] = {i: tf * idf}\n i += 1\n i = 0;\n return vectors","def get_indices_input_target(num_obs, input_len, step_size, forecast_horizon, target_len):\n input_len = round(input_len) # just a precaution\n start_position = 0\n stop_position = num_obs - 1\n\n inpseq_first_idx = start_position\n inpseq_last_idx = inpseq_first_idx + input_len\n target_first_idx = inpseq_last_idx + forecast_horizon\n target_last_idx = target_first_idx + target_len\n print(\"target_last_idx = {}\".format(target_last_idx))\n print(\"stop_position = {}\".format(stop_position))\n indices = []\n while target_last_idx <= stop_position:\n indices.append((inpseq_first_idx, inpseq_last_idx, target_first_idx, target_last_idx))\n inpseq_first_idx += step_size\n inpseq_last_idx += step_size\n target_first_idx += inpseq_last_idx + forecast_horizon\n target_last_idx += target_first_idx + target_len\n return indices","def hoggar_indices():\n return list(product([0,1], repeat=6))","def getIndices(self, tokens):\n tokenTxt, posTxt = attachTokens(tokens)\n if tokenTxt in self.tokenIndices:\n tokenIdx = self.tokenIndices[tokenTxt]\n else:\n tokenIdx = self.tokenIndices[unk]\n if posTxt in self.posIndices:\n posIdx = self.posIndices[posTxt]\n else:\n posIdx = self.posIndices[unk]\n return tokenIdx, posIdx","def mesh_support_idx(self, j):\n self._ensure_mesh()\n supp = self.support_idx(j)\n return (self._knots_to_mesh[supp[0]], self._knots_to_mesh[supp[1]])","def _get_index(self):\n\n return self.index\n\n # to avoid having differences bigger than 2pi","def _iter_indices(self, frame, y):\n pass","def indices(self):\n return tuple([slice(*r) for r in self.location])","def _get_block_indices(y):\n block_labels, block_inv, block_sizes = np.unique(\n y, return_inverse=True, return_counts=True\n )\n\n n_blocks = len(block_labels)\n block_inds = range(n_blocks)\n\n block_vert_inds = []\n for i in block_inds:\n # get the inds from the original graph\n inds = np.where(block_inv == i)[0]\n block_vert_inds.append(inds)\n return block_vert_inds, block_inds, block_inv","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 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 index_to_obs(a,b, grid_x, grid_y):\n position = grid_x[a]\n velocity = grid_y[b]\n return position, velocity","def compute_positions(self):\n return (self.x + DIRECTIONS[self.facing_direction][0]) % (self.image.shape[0] - 1), \\\n (self.y + DIRECTIONS[self.facing_direction][1]) % (self.image.shape[1] - 1)","def morton_idx(pts):\n lib = _initlib()\n p = require(pts, dtype=float64, requirements=['C']) \n inv_cell_width = 1.0/8192\n npts = len(p)\n out = empty(npts, dtype=int64)\n lib.get_morton_idx(p, npts, inv_cell_width, out)\n return out","def _extract_t_indices(self, X, X2=None, dL_dK=None):\r\n\r\n # TODO: some fast checking here to see if this needs recomputing?\r\n self._t = X[:, 0]\r\n if not X.shape[1] == 2:\r\n raise ValueError('Input matrix for ode1 covariance should have two columns, one containing times, the other output indices')\r\n self._index = np.asarray(X[:, 1],dtype=np.int)\r\n # Sort indices so that outputs are in blocks for computational\r\n # convenience.\r\n self._order = self._index.argsort()\r\n self._index = self._index[self._order]\r\n self._t = self._t[self._order]\r\n self._rorder = self._order.argsort() # rorder is for reversing the order\r\n \r\n if X2 is None:\r\n self._t2 = None\r\n self._index2 = None\r\n self._order2 = self._order\r\n self._rorder2 = self._rorder\r\n else:\r\n if not X2.shape[1] == 2:\r\n raise ValueError('Input matrix for ode1 covariance should have two columns, one containing times, the other output indices')\r\n self._t2 = X2[:, 0]\r\n self._index2 = np.asarray(X2[:, 1],dtype=np.int)\r\n self._order2 = self._index2.argsort()\r\n self._index2 = self._index2[self._order2]\r\n self._t2 = self._t2[self._order2]\r\n self._rorder2 = self._order2.argsort() # rorder2 is for reversing order\r\n\r\n if dL_dK is not None:\r\n self._dL_dK = dL_dK[self._order, :]\r\n self._dL_dK = self._dL_dK[:, self._order2]","def getstate(self):\r\n return [self.tied_indices,\r\n self.fixed_indices,\r\n self.fixed_values,\r\n self.constrained_indices,\r\n self.constraints]","def get_img_indices():\n if K.image_dim_ordering() == 'th':\n return 0, 1, 2, 3\n else:\n return 0, 3, 1, 2","def _fixed_indicies(self):\n fixed_inds = self.constraints == 'fixed'\n return fixed_inds","def create_vectors(self):\n self.localStatistics = []\n self.lastStatistics = []\n self.globalV = []\n self.estimate = []\n self.delta = []\n self.drift = []\n self.slack = [] # only for coordBased model","def test_y_vector_init(self):\n # If you change the y-vector ordering, change here too #Y_VECTOR_CHANGESITE\n\n eng_fields = np.zeros(EngineeringState.N_ENGINEERING_FIELDS)\n component_array = eng_fields[EngineeringState._COMPONENT_START_INDEX:EngineeringState._COMPONENT_END_INDEX]\n for comp_i in range(0, N_COMPONENTS):\n component_array[comp_i + N_COMPONENTS * 0] = True # connected\n component_array[comp_i + N_COMPONENTS * 1] = 1 + (0.01 * comp_i) # capacity\n component_array[comp_i + N_COMPONENTS * 2] = 222200 + comp_i # temperature\n component_array[comp_i + N_COMPONENTS * 3] = comp_i % 2 # coolant_hab_one\n component_array[comp_i + N_COMPONENTS * 4] = True # coolant_hab_two\n component_array[comp_i + N_COMPONENTS * 5] = False # coolant_ayse\n\n coolant_array = eng_fields[EngineeringState._COOLANT_START_INDEX:EngineeringState._COOLANT_END_INDEX]\n for cool_i in range(0, N_COOLANT_LOOPS):\n coolant_array[cool_i + N_COOLANT_LOOPS * 0] = 555500 + cool_i # coolant_temp\n coolant_array[cool_i + N_COOLANT_LOOPS * 1] = cool_i % 2 # primary_pump_on\n coolant_array[cool_i + N_COOLANT_LOOPS * 2] = True # secondary_pump_on\n\n rad_array = eng_fields[EngineeringState._RADIATOR_START_INDEX:EngineeringState._RADIATOR_END_INDEX]\n for rad_i in range(0, N_RADIATORS):\n rad_array[rad_i + N_RADIATORS * 0] = rad_i % 4 # attached_to_coolant_loop\n rad_array[rad_i + N_RADIATORS * 1] = rad_i % 2 # functioning\n\n y0 = np.concatenate((np.array([\n 0x111, 0x222, # x\n 0x333, 0x444, # y\n 0x555, 0x777, # vx\n 0x888, 0x999, # vy\n 0.01, 0.02, # heading\n 0.03, 0.04, # spin\n 0xEEE, 0xFFF, # fuel\n 5, 6, # throttle\n 1, -1, # only First is landed on Second\n 0, 1, # Second is broken\n common.SRB_EMPTY,\n 1 # time_acc\n ]),\n eng_fields\n ))\n\n ps = PhysicsState(y0, self.proto_state)\n self.assertTrue(np.array_equal(ps.y0(), y0.astype(ps.y0().dtype)))\n self.assertEqual(ps['First'].landed_on, 'Second')\n\n proto_state = ps.as_proto()\n proto_state.timestamp = 50\n self.assertEqual(proto_state.entities[0].x, 0x111)\n self.assertEqual(proto_state.entities[0].y, 0x333)\n self.assertEqual(proto_state.entities[1].x, 0x222)\n self.assertEqual(proto_state.entities[1].y, 0x444)\n self.assertEqual(proto_state.entities[0].vx, 0x555)\n self.assertEqual(proto_state.entities[0].vy, 0x888)\n self.assertEqual(proto_state.entities[1].vx, 0x777)\n self.assertEqual(proto_state.entities[1].vy, 0x999)\n self.assertEqual(proto_state.entities[0].heading, 0.01)\n self.assertEqual(proto_state.entities[1].heading, 0.02)\n self.assertEqual(proto_state.entities[0].spin, 0.03)\n self.assertEqual(proto_state.entities[1].spin, 0.04)\n self.assertEqual(proto_state.entities[0].fuel, 0xEEE)\n self.assertEqual(proto_state.entities[1].fuel, 0xFFF)\n self.assertEqual(proto_state.entities[0].landed_on, 'Second')\n self.assertEqual(proto_state.entities[1].landed_on, '')\n self.assertEqual(proto_state.timestamp, 50)\n self.assertTrue(proto_state.entities[1].broken)\n\n for i, component in enumerate(ps.engineering.components):\n self.assertEqual(component.connected, True, msg=i)\n self.assertEqual(component.capacity, 1 + (0.01 * i), msg=i)\n self.assertEqual(component.temperature, 222200 + i, msg=i)\n self.assertEqual(component.coolant_hab_one, bool(i % 2), msg=i)\n self.assertEqual(component.coolant_hab_two, True, msg=i)\n self.assertEqual(component.coolant_ayse, False, msg=i)\n\n for i, coolant in enumerate(ps.engineering.coolant_loops):\n self.assertEqual(coolant.coolant_temp, 555500 + i, msg=i)\n self.assertEqual(coolant.primary_pump_on, bool(i % 2), msg=i)\n self.assertEqual(coolant.secondary_pump_on, True, msg=i)\n\n for i, radiator in enumerate(ps.engineering.radiators):\n pass\n self.assertEqual(radiator.attached_to_coolant_loop, i % 4, msg=i)\n self.assertEqual(radiator.functioning, bool(i % 2), msg=i)","def _get_block_indices(y: np.ndarray) -> Tuple[List[np.ndarray], range, np.ndarray]:\n block_labels: np.ndarray\n block_inv: np.ndarray\n block_sizes: np.ndarray\n block_labels, block_inv, block_sizes = np.unique(\n y, return_inverse=True, return_counts=True\n )\n\n n_blocks = len(block_labels)\n block_inds = range(n_blocks)\n\n block_vert_inds = []\n for i in block_inds:\n # get the inds from the original graph\n inds = np.where(block_inv == i)[0]\n block_vert_inds.append(inds)\n return block_vert_inds, block_inds, block_inv","def expandcal(self):\n ind=np.zeros(self.spec.shape[0]).astype(int)\n for k in range(self.nscan):\n ind[self.getscanind(k)]=k\n ind[self.getcalind(k)]=k\n return ind","def velocities(self, return_np=False):\n if return_np:\n return self.si_values()[3:]\n return [self.v_x, self.v_y, self.v_z]","def min_indices(self):\n return {term.minterm_index for term in self.iter_minterms()}","def indices(self, _user=None):\n return [p.index for p in self.get_active_smallvariant_cases()]","def box_collision_info(self):\r\n position = np.zeros((self.Npart,3)) # antall part, dim, iterasjoner\r\n position[:,:] = np.random.uniform(0,1e-6, size = (self.Npart,3))\r\n velocity = np.zeros((self.Npart,3))\r\n velocity[:,:] = np.random.normal(0,self.sigma,size = (self.Npart,3))\r\n\r\n part_collided = 0\r\n part_escaped = 0\r\n momentum = 0\r\n\r\n print 'engine started'\r\n for i in xrange(1,self.n):\r\n #collision\r\n position += velocity*dt\r\n l_hole = position[:,0:2] > self.L/4\r\n h_hole = position[:,0:2] < (3*self.L)/4\r\n pos_xy = np.logical_and(l_hole, h_hole)\r\n pos_xy = np.logical_and(pos_xy[:,0], pos_xy[:,1])\r\n pos_z = position[:,2] < 0\r\n esc_part = np.logical_and(pos_z, pos_xy)\r\n\r\n #velocity[esc_part] = velocity[esc_part]\r\n part_escaped += np.sum(esc_part)\r\n\r\n for j in xrange(0,3):\r\n impact_wall_pos = np.logical_and(position[:,j] > 0,\r\n position[:,j] < self.L)\r\n velocity[np.logical_not(impact_wall_pos),j] = -velocity[\r\n np.logical_not(impact_wall_pos),j]\r\n\r\n\r\n if j == 0:\r\n part_collided += np.sum(np.logical_not(impact_wall_pos),j)\r\n momentum += np.sum(2*self.m*abs(velocity[np.logical_not(\r\n impact_wall_pos),j]))\r\n\r\n\r\n\r\n position[position < 0] = 0\r\n position[position >self.L] = self.L\r\n\r\n particle_collided = part_collided/2\r\n return position, velocity,part_escaped, impact_wall_pos, particle_collided, momentum","def get_indexes(self):\n indexes = []\n for c in self.components:\n indexes.extend(c.get_indexes())\n return indexes","def vector(molec, dihed, nonH, energy):\n #Torison\n if dihed:\n pass\n #XYZ\n else:\n coords = ()\n if nonH:\n for atom in molec.atoms:\n coords += atom.coords\n else:\n for atom in molec.atoms:\n if atom.atomicnum > 1:\n coords += atom.coords\n #Energy\n if energy:\n coords += (molec.energy/10.0,)\n return coords","def get_final_pruned_indices(self):\n return self.final_pruned_indices","def calculate_useful_stuff(self):\n\n self.pos = self.pair[1].position - self.pair[0].position\n self.vel = self.pair[1].velocity - self.pair[0].velocity\n\n self.r = self.pos.length()\n self.v = self.vel.length()\n self.inv_r = 1.0 / self.r\n\n self.rvec = self.pos * self.inv_r\n self.rdot = (self.rvec * self.vel).sum() * self.rvec\n self.rdot_mag = self.rdot.length()\n\n self.vth = self.vel - self.rdot\n self.vth_mag = self.vth.length()\n self.vth_vec = self.vth / self.vth_mag","def velocity_field(self):\n return scipy.dstack((self._u_int, self._v_int))","def get_segment_index(datadb):\n #match in time!!!!\n if cfg.use_saliency:\n segment_index_tar = util.get_time_for_visual(datadb)\n segment_index_tar_future = OrderedDict()\n for key in segment_index_tar.keys():\n segment_index_tar_future[key] = np.array(segment_index_tar[key])+max_encoder_seq_length\n return segment_index_tar,segment_index_tar_future","def get_ecc(self):\n mu_mass = G*(self._mm + self._sm)\n h_mom = self.sp_ang_mom()\n vel = self.getvel_xyz()\n pos = self.getpos_xyz()\n e_vec = 1.0/mu_mass*(np.cross(vel, h_mom) -\n mu_mass*pos/np.linalg.norm(pos))\n return e_vec","def calc_index(self, x, y, model, variable, weights=None, time_weighting=True):\n\n if weights is None:\n # set weights according to cell area\n if x.cell_area is not None:\n weights = x._get_weighting_matrix()\n else:\n print('WARNING: no weights when calculating performance index')\n weights = np.ones(x.data.shape)\n else: # weights are given\n if x.cell_area is not None:\n print('WARNING: cell weights are given, while cell_area available from data!!')\n\n from pycmbs.diagnostic import Diagnostic\n D = Diagnostic(x, y=y)\n # reichler performance index\n # (might return a list if multiple times analyzed)\n e2 = D.calc_reichler_index(weights) # returns [time, index]\n if e2 is not None:\n e2 = np.ma.masked_where(np.isnan(e2), e2)\n\n # Note that the returned value is E**2 for each timestep!\n # When doing the normalization, one needs to take the sqrt(E++2)\n # to obtain the actual RMSE\n if e2 is None:\n return None\n else:\n if time_weighting:\n days = np.asarray(x._days_per_month()) # number of days for each month\n wt = days / float(days.sum()) # weights for time\n else:\n wt = np.ones(len(e2)) / float(len(e2))\n\n return np.sqrt((e2 * wt).sum())","def get_uncut_indices(atoms, orig, vec1, offset=None):\n\n if isinstance(orig, int):\n orig = atoms.get_positions()[orig]\n else:\n orig = np.array(orig)\n if isinstance(vec1, int):\n vec1 = atoms.get_positions()[vec1]\n else:\n vec1 = np.array(vec1)\n\n# if vec2 and isinstance(vec2, int):\n# vec2 = atoms.get_positions()[vec2]\n# elif vec2:\n# vec2 = np.array(vec2)\n# if vec3 and isinstance(vec3, int):\n# vec3 = atoms.get_positions()[vec3]\n# elif vec3:\n# vec3 = np.array(vec3)\n#\n# if vec2:\n# plane_vec = np.cross(vec1-orig, vec2-orig)\n# else:\n# plane_vec = vec1-orig\n#\n# nplane_vec = plane_vec/np.linalg.norm(plane_vec)\n#\n# if vec2 and vec3 and nplane_vec.dot(vec3-orig) < 0:\n# nplane_vec *= -1\n\n plane_vec = vec1 - orig\n nplane_vec = plane_vec/np.linalg.norm(plane_vec)\n\n if offset:\n orig += offset*nplane_vec\n\n atom_indices = [i for i,a in enumerate(atoms) if (a.position - orig).dot(nplane_vec) > 0]\n return atom_indices","def _index(self, i, j):\n assert self._isvalid(i), 'i term (%s) is out of bounds' % i\n assert self._isvalid(j), 'j term (%s) is out of bounds' % j\n\n return self.n * (i - 1) + (j - 1)","def compute_idx(pos, edge_index):\n\n pos_i = pos[edge_index[0]]\n pos_j = pos[edge_index[1]]\n\n d_ij = torch.norm(abs(pos_j - pos_i), dim=-1, keepdim=False).unsqueeze(-1) + 1e-5\n v_ji = (pos_i - pos_j) / d_ij\n\n unique, counts = torch.unique(\n edge_index[0], sorted=True, return_counts=True\n ) # Get central values\n full_index = (\n torch.arange(0, edge_index[0].size()[0]).cuda().int()\n ) # init full index\n\n # Compute 1\n repeat = torch.repeat_interleave(counts, counts)\n counts_repeat1 = torch.repeat_interleave(full_index, repeat) # 0,...,0,1,...,1,...\n\n # Compute 2\n split = torch.split(full_index, counts.tolist()) # split full index\n index2 = list(edge_index[0].data.cpu().numpy()) # get repeat index\n counts_repeat2 = torch.cat(itemgetter(*index2)(split), dim=0) # 0,1,2,...,0,1,2,..\n\n # Compute angle embeddings\n v1 = v_ji[counts_repeat1.long()]\n v2 = v_ji[counts_repeat2.long()]\n\n angle = (v1 * v2).sum(-1).unsqueeze(-1)\n angle = torch.clamp(angle, min=-1.0, max=1.0) + 1e-6 + 1.0\n\n return counts_repeat1.long(), counts_repeat2.long(), angle","def _getitem2d(self, index):\n\n lovects = self._getlovects()\n hivects = self._gethivects()\n fields = self._getfields()\n\n ix = index[0]\n iz = index[1]\n\n if len(fields[0].shape) > self.dim:\n ncomps = fields[0].shape[-1]\n else:\n ncomps = 1\n\n if len(index) > self.dim:\n if ncomps > 1:\n ic = index[2]\n else:\n raise Exception('Too many indices given')\n else:\n ic = None\n\n nx = hivects[0,:].max() - self.nghosts\n nz = hivects[1,:].max() - self.nghosts\n\n if npes > 1:\n nx = comm_world.allreduce(nx, op=mpi.MAX)\n nz = comm_world.allreduce(nz, op=mpi.MAX)\n\n if isinstance(ix, slice):\n ixstart = max(ix.start or -self.nghosts, -self.nghosts)\n ixstop = min(ix.stop or nx + 1 + self.nghosts, nx + self.overlaps[0] + self.nghosts)\n else:\n ixstart = ix\n ixstop = ix + 1\n if isinstance(iz, slice):\n izstart = max(iz.start or -self.nghosts, -self.nghosts)\n izstop = min(iz.stop or nz + 1 + self.nghosts, nz + self.overlaps[1] + self.nghosts)\n else:\n izstart = iz\n izstop = iz + 1\n\n # --- Setup the size of the array to be returned and create it.\n # --- Space is added for multiple components if needed.\n sss = (max(0, ixstop - ixstart),\n max(0, izstop - izstart))\n if ncomps > 1 and ic is None:\n sss = tuple(list(sss) + [ncomps])\n resultglobal = np.zeros(sss, dtype=_libwarpx._numpy_real_dtype)\n\n datalist = []\n for i in range(len(fields)):\n\n # --- The ix1, 2 etc are relative to global indexing\n ix1 = max(ixstart, lovects[0,i])\n ix2 = min(ixstop, lovects[0,i] + fields[i].shape[0])\n iz1 = max(izstart, lovects[1,i])\n iz2 = min(izstop, lovects[1,i] + fields[i].shape[1])\n\n if ix1 < ix2 and iz1 < iz2:\n\n sss = (slice(ix1 - lovects[0,i], ix2 - lovects[0,i]),\n slice(iz1 - lovects[1,i], iz2 - lovects[1,i]))\n if ic is not None:\n sss = tuple(list(sss) + [ic])\n\n vslice = (slice(ix1 - ixstart, ix2 - ixstart),\n slice(iz1 - izstart, iz2 - izstart))\n\n datalist.append((vslice, fields[i][sss]))\n\n if npes == 1:\n all_datalist = [datalist]\n else:\n all_datalist = comm_world.allgather(datalist)\n\n for datalist in all_datalist:\n for vslice, ff in datalist:\n resultglobal[vslice] = ff\n\n # --- Now remove any of the reduced dimensions.\n sss = [slice(None), slice(None)]\n if not isinstance(ix, slice):\n sss[0] = 0\n if not isinstance(iz, slice):\n sss[1] = 0\n\n return resultglobal[tuple(sss)]","def agent_locs_idx(self):\n return tuple(self.agent_locs.T)","def _position_and_velocity(self, jd):\n pos, vel = terra(self.latitude.radians, self.longitude.radians,\n self.elevation.au, jd.gast)\n pos = einsum('ij...,j...->i...', jd.MT, pos)\n vel = einsum('ij...,j...->i...', jd.MT, vel)\n return pos, vel","def indices_hkl(self, H, K, L):\n from cctbx import miller\n _symm_equiv = miller.sym_equiv_indices(self.sg, (H, K, L))\n _indices = sorted([i.h() for i in _symm_equiv.indices()],\n reverse=True)\n if len(_indices) < _symm_equiv.multiplicity(False):\n _indices = _indices + [(-hh, -kk, -ll)\n for (hh, kk, ll) in _indices]\n return _indices","def get_analytical_accelerations(self):\n # create empty numpy array for accelerations\n accelerations = np.zeros((3, len(self.times)))\n # radial accelerations is equal to angular velocity^2 / radius but radius is unitary is this trajectory\n radial_acceleration = self.wz ** 2\n # decompose radial accelerations in x and y components\n accelerations[0, :] = radial_acceleration * -cos(self.th[:, 2])\n accelerations[1, :] = radial_acceleration * -sin(self.th[:, 2])\n # accelerations along x axis is constant\n accelerations[2, :] = self.ax\n return accelerations","def _get_valid_indices(\n self,\n _signals: np.ndarray,\n _labels: np.ndarray,\n window_start_indices: np.ndarray = None,\n elm_start_indices: np.ndarray = None,\n elm_stop_indices: np.ndarray = None,\n valid_t0: np.ndarray = None,\n labels: np.ndarray = None,\n signals: np.ndarray = None,\n ) -> Tuple[\n np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray\n ]:\n # allowed indices; time data points which can be used for creating the data chunks\n _valid_t0 = np.ones(_labels.shape, dtype=np.int32)\n _valid_t0[\n -(config.signal_window_size + config.label_look_ahead) + 1 :\n ] = 0\n\n # indices for active elm events in each elm event\n active_elm_events = np.nonzero(_labels >= 0.5)[0]\n\n if signals is None:\n # initialize arrays\n window_start_indices = np.array([0])\n elm_start_indices = active_elm_events[0]\n elm_stop_indices = active_elm_events[-1]\n valid_t0 = _valid_t0\n signals = _signals\n labels = _labels\n else:\n # concat on axis 0 (time dimension)\n last_index = len(labels) - 1\n window_start_indices = np.append(\n window_start_indices, last_index + 1\n )\n elm_start_indices = np.append(\n elm_start_indices, active_elm_events[0] + last_index + 1\n )\n elm_stop_indices = np.append(\n elm_stop_indices, active_elm_events[-1] + last_index + 1\n )\n valid_t0 = np.concatenate([valid_t0, _valid_t0])\n signals = np.concatenate([signals, _signals], axis=0)\n labels = np.concatenate([labels, _labels], axis=0)\n\n return (\n signals,\n labels,\n valid_t0,\n window_start_indices,\n elm_start_indices,\n elm_stop_indices,\n )","def cal_globalIndexH(self):\n h_local = self.cal_localIndexH()\n h_global = np.sum(h_local)\n\n return h_global","def indices(self):\n if self._indices is None:\n i = []\n\n # TODO: this is not right for multi-column keys\n # TODO: new style indexes\n\n global_name = '^DD(%s,0,\"IX\",\"0\")' % self.fileid\n prefix = '^DD(%s,0,\"IX\",' % self.fileid\n while 1:\n global_name = M.mexec('set s0=$query(%s)' % global_name, M.INOUT(\"\"))[0]\n if not global_name or not global_name.startswith(prefix):\n break\n suffix = global_name[len(prefix):-1]\n parts = suffix.split(\",\")\n idx_name = parts[0][1:-1]\n idx_table = parts[1]\n idx_columns = parts[2:]\n index = Index(idx_name, idx_table, idx_columns)\n i.append(index)\n\n # A second list, gives indices for a field\n columns = {}\n for idx in i:\n for c in idx.columns:\n columns[c] = 1\n\n # Now trawl the listed columns in the data dictionary, and load their\n # cross references.\n cr_names = {}\n for c in columns.keys():\n idx_root = M.Globals[\"^DD\"][self.fileid][c][1]\n if not idx_root[0].exists():\n continue\n for cr_id, val in idx_root.keys_with_decendants():\n if float(cr_id) > 0:\n cr_header = idx_root[cr_id][0].value\n parts = cr_header.split(\"^\")\n if len(parts) == 2 and parts[1]: # if more than 2 parts, assume MUMPs trigger\n f = cr_names.get(parts[1], list())\n f.append(c)\n cr_names[parts[1]] = f\n\n # Now, just delete items from the index list if they are not in cr_names\n self._indices = []\n for index in i:\n cr = cr_names.get(index.name)\n if cr:\n # verify columns - lots of errors in real systems\n if len(cr) == len(index.columns):\n invalid = False\n for c in cr:\n if c not in index.columns:\n invalid = True\n continue\n if not invalid:\n self._indices.append(index)\n\n return self._indices","def calcAllIntensities(self, xc, yc):\n\n tp = 0.0\n ix = 0\n iy = 0\n h = 0\n ints = np.zeros([5, 5])\n ints_inner = np.zeros([5, 5])\n # ints = [[0.0] * 5] * 5\n # ints_inner = [[0.0] * 5] * 5\n x = 0.0\n y = 0.0\n xc1 = 0.0\n yc1 = 0.0\n xc1 = xc\n yc1 = yc\n \n for h in np.arange(1,5,1):\n for k in np.arange(1,5,1):\n ints[h][k] = 0.0\n ints_inner[h][k] = 0.0\n\n for k in np.arange(0, 2, 1):\n for h in np.arange(0, 2, 1):\n for ix in np.arange(0, self.stepp + 1, 1):\n for iy in np.arange(0, self.stepp + 1, 1):\n #print(k, h, ix, iy)\n if self.qc_format == 0 :\n x = -(1 + self.G) + h * (1 + 2 * self.G) + (ix * (1.0 / self.stepp))\n y = -(1 + self.G) + k * (1 + 2 * self.G) + (iy * (1.0 / self.stepp))\n if self.spot_radius == 0 or math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)) == 0 :\n tp = 0.0\n else :\n tp = (math.sin((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))) / ((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))\n tp = math.pow(tp,2)\n #print(tp)\n elif self.qc_format == 1 :\n x = -1 + h + (ix * (1 / self.stepp))\n y = -1 + k + (iy * (1 / self.stepp))\n ints[h + 1][k + 1] += math.pow(math.exp((math.pow((x - xc1),2) + math.pow((y - yc1),2) ) / math.pow(self.spot_radius,2)), -1)\n if (self.spot_radius * self.spot_radius) == 0 or ((x - xc1) * (y - yc1) * np.pi * np.pi) == 0 :\n tp = 0.0\n else :\n tp = (math.sin((x - xc1) * np.pi / self.spot_radius) * math.sin((y - yc1) * np.pi / self.spot_radius)) / (((x - xc1) * (y - yc1) * np.pi * np.pi) / (self.spot_radius * self.spot_radius))\n\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.radius_inner,2):\n ints_inner[h + 1][k + 1] += tp\n else :\n if self.qc_format == 1 :\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.cell_qc, 2):\n ints[h + 1][k + 1] += tp\n if (math.pow(x,2) + math.pow(y,2)) <= 1 :\n #print(math.pow(x,2) + math.pow(y,2))\n ints[h + 1][k + 1] += tp\n # print(ints[h + 1][k + 1])\t\t\t\t\t\t\n tp = 0.0\n\n # print(ints)\n\n Aq = 0.0\n Bq = 0.0\n Cq = 0.0\n Dq = 0.0\n Ac_inner = 0.0\n Bc_inner = 0.0\n Cc_inner = 0.0\n Dc_inner = 0.0\n Ac = 0.0\n Bc = 0.0\n Cc = 0.0\n Dc = 0.0\n Ac = ints[1][2]\n Bc = ints[2][2]\n Cc = ints[2][1]\n Dc = ints[1][1]\n\n Ac_inner = ints_inner[1][2]\n Bc_inner = ints_inner[2][2]\n Cc_inner = ints_inner[2][1]\n Dc_inner = ints_inner[1][1]\n Ac *= self.QE\n Bc *= self.QE\n Cc *= self.QE\n Dc *= self.QE\n\n Ac_inner *= self.QE_inner\n Bc_inner *= self.QE_inner\n Cc_inner *= self.QE_inner\n Dc_inner *= self.QE_inner\n Ac += Ac_inner\n Bc += Bc_inner\n Cc += Cc_inner\n Dc += Dc_inner\n\n Aq = Ac\n Bq = Bc\n Cq = Cc\n Dq = Dc\n\n #tp/TP = cotribution percentage of the spot with respect to max (spot center)\n if self.smooth == 0 :\n if (Config.hplk_c0_e * self.TP) == 0 :\n cnst = 0\n else :\n cnst = ((Parameters.TPS / (self.n_ml * self.n_ml)) * self.lamb) / (Config.hplk_c0_e * self.TP) #Número de fótons efeticos\n if Config.flag_spice == 1 :\n Ac *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP) #W\n Bc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\n Cc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\n Dc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\n Ac *= 1 / (math.pow(self.cell_qc * 1e-6,2)) #W/(m^2)\n Bc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\n Cc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\n Dc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\n #Ac *= 1 / (self.lamb * 1e6); #Adequação da irradiância para a unidade W/m2micm conforme necessário no SPICE\n #Bc *= 1 / (self.lamb * 1e6);\n #Cc *= 1 / (self.lamb * 1e6);\n #Dc *= 1 / (self.lamb * 1e6);\n \n ############################## DOUBLE CHECK ##############################\n # self.grava_arquivos = 1\n # self.flag_V_QC = 0\n # grava_le_arquivos(0) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n # self.flag_V_QC = 1\n # self.grava_arquivos = 0\n ############################## DOUBLE CHECK ##############################\n Aq *= cnst * 1e9\n Bq *= cnst * 1e9\n Cq *= cnst * 1e9\n Dq *= cnst * 1e9\n else :\n Aq *= cnst * 1e9\n Bq *= cnst * 1e9\n Cq *= cnst * 1e9\n Dq *= cnst * 1e9\n\n # 'returns' all the intensities\n self.A_intensity = Aq\n self.B_intensity = Bq\n self.C_intensity = Cq\n self.D_intensity = Dq","def atom_idxs(self):\n\n return np.array([atom.atom_idxs for atom in self])","def crearIndices(self):\n l = self.encontrarCaracteres()\n i=0\n for c in l:\n self.indices[c] = i\n i+=1"],"string":"[\n \"def indices_and_currents_TSC_2D( charge_electron, positions_x, positions_y, velocity_x, velocity_y,\\\\\\n x_grid, y_grid, ghost_cells, length_domain_x, length_domain_y, dt ):\\n \\n \\n positions_x_new = positions_x + velocity_x * dt\\n positions_y_new = positions_y + velocity_y * dt\\n\\n base_indices_x = af.data.constant(0, positions_x.elements(), dtype=af.Dtype.u32)\\n base_indices_y = af.data.constant(0, positions_x.elements(), dtype=af.Dtype.u32)\\n\\n dx = af.sum(x_grid[1] - x_grid[0])\\n dy = af.sum(y_grid[1] - y_grid[0])\\n\\n\\n # Computing S0_x and S0_y\\n ###########################################################################################\\n \\n # Determining the grid cells containing the respective particles\\n \\n x_zone = (((af.abs(positions_x - af.sum(x_grid[0])))/dx).as_type(af.Dtype.u32))\\n y_zone = (((af.abs(positions_y - af.sum(y_grid[0])))/dy).as_type(af.Dtype.u32))\\n\\n \\n # Determing the indices of the closest grid node in x direction\\n\\n temp = af.where(af.abs(positions_x-x_grid[x_zone]) < \\\\\\n af.abs(positions_x-x_grid[x_zone + 1])\\\\\\n )\\n\\n if(temp.elements()>0):\\n base_indices_x[temp] = x_zone[temp]\\n\\n temp = af.where(af.abs(positions_x - x_grid[x_zone]) >= \\\\\\n af.abs(positions_x-x_grid[x_zone + 1])\\\\\\n )\\n\\n if(temp.elements()>0):\\n base_indices_x[temp] = (x_zone[temp] + 1).as_type(af.Dtype.u32) \\n\\n\\n # Determing the indices of the closest grid node in y direction\\n\\n temp = af.where(af.abs(positions_y-y_grid[y_zone]) < \\\\\\n af.abs(positions_y-y_grid[y_zone + 1])\\\\\\n )\\n\\n if(temp.elements()>0):\\n base_indices_y[temp] = y_zone[temp]\\n\\n temp = af.where(af.abs(positions_y - y_grid[y_zone])>=af.abs(positions_y-x_grid[y_zone + 1]))\\n\\n if(temp.elements()>0):\\n base_indices_y[temp] = (y_zone[temp] + 1).as_type(af.Dtype.u32) \\n\\n # Concatenating the index list for near by grid nodes in x direction\\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\\n\\n base_indices_minus_two = (base_indices_x - 2).as_type(af.Dtype.u32) \\n base_indices_minus = (base_indices_x - 1).as_type(af.Dtype.u32) \\n base_indices_plus = (base_indices_x + 1).as_type(af.Dtype.u32) \\n base_indices_plus_two = (base_indices_x + 2).as_type(af.Dtype.u32) \\n\\n\\n\\n index_list_x = af.join( 1,\\\\\\n af.join(1, base_indices_minus_two, base_indices_minus, base_indices_x),\\\\\\n af.join(1, base_indices_plus, base_indices_plus_two),\\\\\\n )\\n\\n\\n\\n # Concatenating the index list for near by grid nodes in y direction\\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\\n \\n base_indices_minus_two = (base_indices_y - 2).as_type(af.Dtype.u32) \\n base_indices_minus = (base_indices_y - 1).as_type(af.Dtype.u32) \\n base_indices_plus = (base_indices_y + 1).as_type(af.Dtype.u32) \\n base_indices_plus_two = (base_indices_y + 2).as_type(af.Dtype.u32) \\n\\n\\n index_list_y = af.join( 1,\\\\\\n af.join(1, base_indices_minus_two, base_indices_minus, base_indices_y),\\\\\\n af.join(1, base_indices_plus, base_indices_plus_two),\\\\\\n )\\n\\n # Concatenating the positions_x for determining weights for near by grid nodes in y direction\\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\\n\\n positions_x_5x = af.join( 0,\\\\\\n af.join(0, positions_x, positions_x, positions_x),\\\\\\n af.join(0, positions_x, positions_x),\\\\\\n )\\n\\n positions_y_5x = af.join( 0,\\\\\\n af.join(0, positions_y, positions_y, positions_y),\\\\\\n af.join(0, positions_y, positions_y),\\\\\\n )\\n\\n\\n\\n\\n # Determining S0 for positions at t = n * dt\\n\\n\\n distance_nodes_x = x_grid[af.flat(index_list_x)]\\n\\n distance_nodes_y = y_grid[af.flat(index_list_y)]\\n\\n\\n W_x = 0 * distance_nodes_x.copy()\\n W_y = 0 * distance_nodes_y.copy()\\n\\n\\n # Determining weights in x direction\\n\\n temp = af.where(af.abs(distance_nodes_x - positions_x_5x) < (0.5*dx) )\\n\\n if(temp.elements()>0):\\n W_x[temp] = 0.75 - (af.abs(distance_nodes_x[temp] - positions_x_5x[temp])/dx)**2\\n\\n temp = af.where((af.abs(distance_nodes_x - positions_x_5x) >= (0.5*dx) )\\\\\\n * (af.abs(distance_nodes_x - positions_x_5x) < (1.5 * dx) )\\\\\\n )\\n\\n if(temp.elements()>0):\\n W_x[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_x[temp] - positions_x_5x[temp])/dx))**2\\n\\n\\n\\n # Determining weights in y direction\\n\\n temp = af.where(af.abs(distance_nodes_y - positions_y_5x) < (0.5*dy) )\\n\\n if(temp.elements()>0):\\n W_y[temp] = 0.75 - (af.abs(distance_nodes_y[temp] - positions_y_5x[temp])/dy)**2\\n\\n temp = af.where((af.abs(distance_nodes_y - positions_y_5x) >= (0.5*dy) )\\\\\\n * (af.abs(distance_nodes_y - positions_y_5x) < (1.5 * dy) )\\\\\\n )\\n\\n if(temp.elements()>0):\\n W_y[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_y[temp] - positions_y_5x[temp])/dy))**2\\n\\n # Restructering W_x and W_y for visualization and ease of understanding\\n\\n W_x = af.data.moddims(W_x, positions_x.elements(), 5)\\n W_y = af.data.moddims(W_y, positions_y.elements(), 5)\\n\\n # Tiling the S0_x and S0_y for the 25 indices around the particle\\n \\n S0_x = af.tile(W_x, 1, 1, 5)\\n S0_y = af.tile(W_y, 1, 1, 5)\\n\\n\\n S0_y = af.reorder(S0_y, 0, 2, 1)\\n\\n\\n\\n #Computing S1_x and S1_y\\n ###########################################################################################\\n\\n positions_x_5x_new = af.join( 0,\\\\\\n af.join(0, positions_x_new, positions_x_new, positions_x_new),\\\\\\n af.join(0, positions_x_new, positions_x_new),\\\\\\n )\\n\\n positions_y_5x_new = af.join( 0,\\\\\\n af.join(0, positions_y_new, positions_y_new, positions_y_new),\\\\\\n af.join(0, positions_y_new, positions_y_new),\\\\\\n )\\n\\n\\n\\n\\n # Determining S0 for positions at t = n * dt\\n\\n W_x = 0 * distance_nodes_x.copy()\\n W_y = 0 * distance_nodes_y.copy()\\n\\n\\n # Determining weights in x direction\\n\\n temp = af.where(af.abs(distance_nodes_x - positions_x_5x_new) < (0.5*dx) )\\n\\n if(temp.elements()>0):\\n W_x[temp] = 0.75 - (af.abs(distance_nodes_x[temp] - positions_x_5x_new[temp])/dx)**2\\n\\n temp = af.where((af.abs(distance_nodes_x - positions_x_5x_new) >= (0.5*dx) )\\\\\\n * (af.abs(distance_nodes_x - positions_x_5x_new) < (1.5 * dx) )\\\\\\n )\\n\\n if(temp.elements()>0):\\n W_x[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_x[temp] \\\\\\n - positions_x_5x_new[temp])/dx\\\\\\n )\\\\\\n )**2\\n\\n\\n\\n # Determining weights in y direction\\n\\n temp = af.where(af.abs(distance_nodes_y - positions_y_5x_new) < (0.5*dy) )\\n\\n if(temp.elements()>0):\\n W_y[temp] = 0.75 - (af.abs(distance_nodes_y[temp] \\\\\\n - positions_y_5x_new[temp]\\\\\\n )/dy\\\\\\n )**2\\n\\n temp = af.where((af.abs(distance_nodes_y - positions_y_5x_new) >= (0.5*dy) )\\\\\\n * (af.abs(distance_nodes_y - positions_y_5x_new) < (1.5 * dy) )\\\\\\n )\\n\\n if(temp.elements()>0):\\n W_y[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_y[temp] \\\\\\n - positions_y_5x_new[temp])/dy\\\\\\n )\\\\\\n )**2\\n\\n # Restructering W_x and W_y for visualization and ease of understanding\\n\\n W_x = af.data.moddims(W_x, positions_x.elements(), 5)\\n W_y = af.data.moddims(W_y, positions_x.elements(), 5)\\n\\n # Tiling the S0_x and S0_y for the 25 indices around the particle \\n \\n S1_x = af.tile(W_x, 1, 1, 5)\\n S1_y = af.tile(W_y, 1, 1, 5)\\n\\n S1_y = af.reorder(S1_y, 0, 2, 1)\\n\\n\\n ###########################################################################################\\n\\n # Determining the final weight matrix for currents in 3D matrix form factor\\n\\n\\n W_x = (S1_x - S0_x) * (S0_y + (0.5 *(S1_y - S0_y)) )\\n\\n\\n W_y = (S1_y - S0_y) * (S0_x + (0.5 *(S1_x - S0_x)) )\\n\\n\\n ###########################################################################################\\n\\n\\n # Assigning Jx and Jy according to Esirkepov's scheme\\n\\n Jx = af.data.constant(0, positions_x.elements(), 5, 5, dtype = af.Dtype.f64)\\n Jy = af.data.constant(0, positions_x.elements(), 5, 5, dtype = af.Dtype.f64)\\n\\n\\n Jx[:, 0, :] = -1 * charge_electron * (dx/dt) * W_x[:, 0, :].copy()\\n Jx[:, 1, :] = Jx[:, 0, :] + -1 * charge_electron * (dx/dt) * W_x[:, 1, :].copy()\\n Jx[:, 2, :] = Jx[:, 1, :] + -1 * charge_electron * (dx/dt) * W_x[:, 2, :].copy()\\n Jx[:, 3, :] = Jx[:, 2, :] + -1 * charge_electron * (dx/dt) * W_x[:, 3, :].copy()\\n Jx[:, 4, :] = Jx[:, 3, :] + -1 * charge_electron * (dx/dt) * W_x[:, 4, :].copy()\\n \\n # Computing current density using currents\\n \\n Jx = (1/(dx * dy)) * Jx\\n\\n\\n Jy[:, :, 0] = -1 * charge_electron * (dy/dt) * W_y[:, :, 0].copy()\\n Jy[:, :, 1] = Jy[:, :, 0] + -1 * charge_electron * (dy/dt) * W_y[:, :, 1].copy()\\n Jy[:, :, 2] = Jy[:, :, 1] + -1 * charge_electron * (dy/dt) * W_y[:, :, 2].copy()\\n Jy[:, :, 3] = Jy[:, :, 2] + -1 * charge_electron * (dy/dt) * W_y[:, :, 3].copy()\\n Jy[:, :, 4] = Jy[:, :, 3] + -1 * charge_electron * (dy/dt) * W_y[:, :, 4].copy()\\n \\n # Computing current density using currents\\n\\n Jy = (1/(dx * dy)) * Jy\\n\\n # Preparing the final index and current vectors\\n ###########################################################################################\\n \\n \\n # Determining the x indices for charge deposition\\n index_list_x_Jx = af.flat(af.tile(index_list_x, 1, 1, 5))\\n\\n # Determining the y indices for charge deposition\\n y_current_zone = af.tile(index_list_y, 1, 1, 5)\\n index_list_y_Jx = af.flat(af.reorder(y_current_zone, 0, 2, 1))\\n\\n\\n currents_Jx = af.flat(Jx)\\n\\n # Determining the x indices for charge deposition\\n index_list_x_Jy = af.flat(af.tile(index_list_x, 1, 1, 5))\\n\\n # Determining the y indices for charge deposition\\n y_current_zone = af.tile(index_list_y, 1, 1, 5)\\n index_list_y_Jy = af.flat(af.reorder(y_current_zone, 0, 2, 1))\\n \\n # Flattenning the Currents array\\n currents_Jy = af.flat(Jy)\\n\\n af.eval(index_list_x_Jx, index_list_y_Jx)\\n af.eval(index_list_x_Jy, index_list_y_Jy)\\n af.eval(currents_Jx, currents_Jy)\\n\\n\\n return index_list_x_Jx, index_list_y_Jx, currents_Jx,\\\\\\n index_list_x_Jy, index_list_y_Jy, currents_Jy\",\n \"def generate_index(self):\\n begin_o, end_o, begin_a, end_a = 0, 0, 0, 0\\n for obs_space, act_space in zip(self.env.observation_space, self.env.action_space):\\n end_o = end_o + obs_space.shape[0]\\n if isinstance(act_space, Box):\\n end_a = act_space.shape[0]\\n else:\\n end_a = act_space.n\\n range_o = (begin_o, end_o)\\n range_a = (begin_a, end_a)\\n self.observation_index.append(range_o)\\n self.action_index.append(range_a)\\n begin_o = end_o\\n begin_a = end_a\",\n \"def mesh_span_indices(self):\\n self._ensure_mesh()\\n k2m = self._knots_to_mesh\\n return np.where(k2m[1:] != k2m[:-1])[0]\",\n \"def get_index(self, x, y):\\n i = (y - self.y0) // self.dy\\n j = (x - self.x0) // self.dx\\n i = min(max(i, 0), self.n-1)\\n j = min(max(j, 0), self.m-1)\\n return [i, j]\",\n \"def calculate_esi_index(radius, mass, temperature):\\n density = Calculator.calculate_average_density(radius, mass)\\n escape_velocity = Calculator.calculate_escape_velocity(radius, mass)\\n\\n factors = [\\n (radius, 6.3781e6, 0.57/4),\\n (density, 5513, 1.07/4),\\n (escape_velocity, 11200, 0.70/4),\\n (temperature, 288, 5.58/4)\\n ]\\n res = [(1 - abs(x - y)/abs(x + y)) ** z for x, y, z in factors]\\n return functools.reduce(operator.mul, res)\",\n \"def mainIndices(self):\\n return self.i1, self.i2\",\n \"def get_indices(self):\\r\\n return self._indices\",\n \"def indices(self) -> np.ndarray:\\n return self.impl.indices\",\n \"def __build_state_index(self):\\n\\n # the index for the system state\\n # [rho_i, q_in, q_out, r_i, f_i]\\n x_index = {}\\n\\n # add the density index\\n x_index['density'] = OrderedDict()\\n for i in range(0, self.num_cells):\\n x_index['density'][i] = i\\n dim_state = self.num_cells\\n\\n # add the upstream boundary flow\\n x_index['qin'] = dim_state\\n x_index['qout'] = dim_state + 1\\n dim_state += 2\\n\\n # add on ramp variables\\n # x_index['onramp'] = OrderedDict()\\n # if self.cell_onramp is not None:\\n # # if onramp exist in the network, otherwise skip\\n # for cell_id in self.cell_onramp:\\n # # add the absolute index into the state index dictionary\\n # # r_i index = self.x_index{'onramp'][cell_i]\\n # x_index['onramp'][cell_id] = dim_state\\n # dim_state += 1\\n #\\n #\\n # # add off ramp state variables\\n # x_index['offramp'] = OrderedDict()\\n # if self.cell_offramp is not None:\\n # for cell_id in self.cell_offramp:\\n # # add the absolute index\\n # x_index['offramp'][cell_id] = dim_state\\n # dim_state += 1\\n\\n return x_index, dim_state\",\n \"def indices(self):\\n _indices = []\\n for h in self.miller.indices():\\n _indices.append(self.indices_hkl(*h)[0])\\n return _indices\",\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 get_index(self):\\n return (np.sqrt(self.dielectric))\",\n \"def create_elastic_indices():\\n # initial values\\n alpha, alpha2, sigma = 10, 10, 50\\n shape = (96, 288) # same as shape of input images\\n x_mesh, y_mesh = np.meshgrid(np.arange(shape[1]), np.arange(shape[0]))\\n\\n # below is used once per epoch for the elastic deformation\\n g_1d = signal.gaussian(300, sigma)\\n kernel_deform = np.outer(g_1d, g_1d)\\n dx = signal.fftconvolve(np.random.rand(*shape) * 2 - 1, kernel_deform, mode='same')\\n dy = signal.fftconvolve(np.random.rand(*shape) * 2 - 1, kernel_deform, mode='same')\\n dx = alpha * (dx - np.mean(dx)) / np.std(dx)\\n dy = alpha2 * (dy - np.mean(dy)) / np.std(dy)\\n indices_x, indices_y = x_mesh + dx, y_mesh + dy\\n indices_x_clipped = np.clip(indices_x, a_min=0, a_max=shape[1] - 1)\\n indices_y_clipped = np.clip(indices_y, a_min=0, a_max=shape[0] - 1)\\n return indices_x_clipped, indices_y_clipped\",\n \"def get_idx(velocity, coord):\\n d = velocity.node_intervals\\n dx=d[0]\\n dz=d[1]\\n dy=d[2]\\n mn = velocity.min_coords\\n mnx=mn[0]\\n mnz=mn[1]\\n mny=mn[2]\\n ix = int((coord[0] - mnx)/dx)\\n iz = int((coord[1] - mnz)/dz)\\n iy = int((coord[2] - mny)/dy)\\n return (ix, iz, iy)\",\n \"def _get_k_indices(self, ks):\\n if self.staticneighs:\\n idx_ks = ks\\n else:\\n idx_ks = [self.ks.index(e) for e in ks]\\n return idx_ks\",\n \"def indices(self):\\n return self.index.indices\",\n \"def get_analytical_velocities(self):\\n # create empty numpy array for accelerations\\n velocities = np.zeros((3, len(self.times)))\\n # tangential velocity is angular velocity multiplied by radius but radius is one\\n vt = self.wz\\n # decompose tangential velocity in x and y components\\n velocities[0, :] = vt * -sin(self.th[:, 2])\\n velocities[1, :] = vt * cos(self.th[:, 2])\\n # linear velocity along z axis\\n velocities[2, :] = self.v0x + self.ax * self.times\\n return velocities\",\n \"def getIndices(self):\\r\\n return self._indices\",\n \"def Indexes(self, latitudes, longitudes):\\n res = self._transform.TransformPoints(\\n np.column_stack((longitudes, latitudes)))\\n res = list(zip(*res))\\n x, y = np.array(res[0]), np.array(res[1])\\n idx_col = self._inv_txf[0] + self._inv_txf[1] * x + self._inv_txf[2] * y\\n idx_row = self._inv_txf[3] + self._inv_txf[4] * x + self._inv_txf[5] * y\\n return idx_row.astype(int), idx_col.astype(int)\",\n \"def indices(self):\\n i, j, _edge = self.indicesAndEdge()\\n return i, j\",\n \"def update_idx(self):\\n self.idx = (self.F * self.FMUL +\\n self.E * self.EMUL +\\n self.Z * self.ZMUL +\\n self.A * self.AMUL +\\n self.B * self.BMUL )\",\n \"def vir_indices(self):\\n indices = []\\n for index,item in enumerate(self):\\n if item==0:\\n indices.append(index)\\n return indices\",\n \"def master_ndindex(self): # itermaster_indices(self):\\n return itertools_product(\\n *[range(*r) for r in self.location]\\n ) # TODO check\",\n \"def coord_indices_of(self, v_list):\\n return [self.coord_index_of(v) for v in v_list]\",\n \"def efficient_integer_vectors(self):\\n return self._efficient_integer_vectors\",\n \"def test_get_indices_several_existing_items(self):\\r\\n control_ids = ['PC.354', 'PC.355', 'PC.356', 'PC.481', 'PC.593']\\r\\n exp_control_indices = [0, 1, 2, 3, 4]\\r\\n\\r\\n fast_ids = ['PC.607', 'PC.634', 'PC.635', 'PC.636']\\r\\n exp_fast_indices = [5, 6, 7, 8]\\r\\n\\r\\n obs_control = _get_indices(self.dist_matrix_header, control_ids)\\r\\n self.assertEqual(obs_control, exp_control_indices)\\r\\n\\r\\n obs_fast = _get_indices(self.dist_matrix_header, fast_ids)\\r\\n self.assertEqual(obs_fast, exp_fast_indices)\",\n \"def _state_index(state):\\n delta_y, delta_x, bird_lmh, pipe_lmh, is_flapping = state\\n actions, height, width, _, _, _ = Q.shape\\n\\n y = int((height / 2) + (delta_y / step_r) - 1)\\n x = int((width / 2) + (delta_x / step_c) - 1)\\n\\n return y, x, bird_lmh, pipe_lmh, is_flapping\",\n \"def get_analytically_computed_optimization_parameter_indices(self):\\n indices = []\\n if '/offsetParameterIndices' in self.f:\\n indices.extend(self.f['/offsetParameterIndices'])\\n\\n if '/scalingParameterIndices' in self.f:\\n indices.extend(self.f['/scalingParameterIndices'])\\n\\n if '/sigmaParameterIndices' in self.f:\\n indices.extend(self.f['/sigmaParameterIndices'])\\n\\n return list(set(indices))\",\n \"def calc_target_index(self, state, cx, cy):\\n # Calc front axle position\\n fx = state.x + self.L * np.cos(state.yaw) / 2.0\\n fy = state.y + self.L * np.sin(state.yaw) / 2.0\\n\\n # Search nearest point index\\n dx = []\\n dy = []\\n\\n i = 0\\n for icx in cx:\\n if i < self.ind - 1000:\\n dx.append(float(\\\"inf\\\"))\\n else:\\n dx.append(fx - icx)\\n i += 1\\n\\n i = 0\\n for icy in cy:\\n if i < self.ind - 1000:\\n dy.append(float(\\\"inf\\\"))\\n else:\\n dy.append(fy - icy)\\n i += 1\\n\\n # dx = [fx - icx for icx in cx]\\n # dy = [fy - icy for icy in cy]\\n\\n d = np.hypot(dx, dy)\\n target_idx = np.argmin(d)\\n\\n # Project RMS error onto front axle vector\\n front_axle_vec = [-np.cos(state.yaw + np.pi / 2), -\\n np.sin(state.yaw + np.pi / 2)]\\n\\n error_front_axle = np.dot(\\n [dx[target_idx], dy[target_idx]], front_axle_vec)\\n\\n\\n\\n return target_idx, error_front_axle\",\n \"def calculate_index_and_derivative(wl):\\n index = np.sqrt(1 + (0.6961663 * wl * wl) / (wl * wl - 0.0684043 * 0.0684043)\\n + (0.4079426 * wl * wl) / (wl * wl - 0.1162414 * 0.1162414)\\n + (0.8974794 * wl * wl) / (wl * wl - 9.896161 * 9.896161)\\n )\\n\\n index_derivative = \\\\\\n (\\n - (1.79496 * wl * wl * wl) / (pow(-97.934 + wl * wl, 2))\\n + (1.79496 * wl) / (-97.934 + wl * wl)\\n\\n - (0.815885 * wl * wl * wl) / (pow(-0.0135121 + wl * wl, 2))\\n + (0.815885 * wl) / (-0.0135121 + wl * wl)\\n\\n - (1.39233 * wl * wl * wl) / (pow(-0.00467915 + wl * wl, 2))\\n + (1.39233 * wl) / (-0.00467915 + wl * wl)\\n ) \\\\\\n / \\\\\\n (2 * np.sqrt(\\n 1\\n + (0.897479 * wl * wl) / (-97.934 + wl * wl)\\n + (0.407943 * wl * wl) / (-0.0135121 + wl * wl)\\n + (0.696166 * wl * wl) / (-0.00467915 + wl * wl)\\n )\\n )\\n return index, index_derivative\",\n \"def indices(self):\\n return range(len(self))\",\n \"def get_local_indices(self, part, ctx):\\n return self.map_to_global(\\n F.arange(0, self.local_size(part), ctx=ctx), part\\n )\",\n \"def damping_index(self):\\n start_index = self.kp_index[1]\\n end_index = start_index + self.control_dim\\n\\n if self.impedance_flag:\\n return (start_index, end_index)\\n else:\\n return None\",\n \"def comp_amplification_index(self):\\n \\n self.grid_tuning_in=self.inputs.grid_tuning_in\\n self.grid_tuning_out=gl.comp_grid_tuning_index(self.L,self.nx,(self.r[0:self.n_e**2,:]).T) \\n self.grid_tuning_out_inhib=gl.comp_grid_tuning_index(self.L,self.nx,(self.r[self.n_e**2:,:]).T)\\n\\n self.grid_amp_index=self.grid_tuning_out/self.grid_tuning_in\",\n \"def compute_tides(self):\\r\\n # take the period of the asteroid rotation\\r\\n P = self.period\\r\\n\\r\\n # compute the angle of the asteroid\\r\\n phase = 2*np.pi*(float(self.t) % P)/P\\r\\n\\r\\n # get points\\r\\n points = self.V.tabulate_dof_coordinates()[::3]\\r\\n\\r\\n # rotate points to the position they should be in, in the solar frame\\r\\n points = self.rotate_points(points, -phase)\\r\\n\\r\\n # get the acceleration, multiplies by rho\\r\\n force = float(self.rho)*self.tidal_acc(points)\\r\\n\\r\\n # rotate the force back to the actual points\\r\\n force = self.rotate_points(force, phase)\\r\\n\\r\\n # update the force function from the array\\r\\n self.ftides.vector()[:] = force.flatten()\",\n \"def get_vacancy_indices(array):\\t\\n\\tvacancy_indices = np.argwhere(array == 0)\\n\\treturn vacancy_indices\",\n \"def _get_indexes(self, participants):\\n tr_idx = int(np.floor(self.tr_size*len(participants)))\\n j = self.val_size + self.tr_size\\n val_idx = int(np.floor(j*len(participants)))\\n return tr_idx, val_idx\",\n \"def indices(self):\\n return self._kbounded_partitions\",\n \"def build_amg_index_sets(L_sizes):\\n neqns = L_sizes[0][0]\\n velocityDOF=[]\\n for start in range(1,3):\\n velocityDOF.append(np.arange(start=start,\\n stop=1+neqns,\\n step=3,\\n dtype='i'))\\n velocityDOF_full=np.vstack(velocityDOF).transpose().flatten()\\n velocity_u_DOF = []\\n velocity_u_DOF.append(np.arange(start=0,\\n stop=2*neqns//3,\\n step=2,\\n dtype='i'))\\n velocity_u_DOF_full = np.vstack(velocity_u_DOF).transpose().flatten()\\n velocity_v_DOF = []\\n velocity_v_DOF.append(np.arange(start=1,\\n stop=1+2*neqns//3,\\n step=2,\\n dtype='i'))\\n velocity_v_DOF_full = np.vstack(velocity_v_DOF).transpose().flatten()\\n isvelocity = PETSc.IS()\\n isvelocity.createGeneral(velocityDOF_full)\\n isu = PETSc.IS()\\n isu.createGeneral(velocity_u_DOF_full)\\n isv = PETSc.IS()\\n isv.createGeneral(velocity_v_DOF_full)\\n return [isvelocity, isu, isv]\",\n \"def two_dim_index(self, k):\\n ind_x = k % self.nx\\n ind_y = (k - ind_x) / self.nx\\n return (int(ind_y), int(ind_x))\",\n \"def csm_indices(csm):\\r\\n return csm_properties(csm)[1]\",\n \"def getGlobalIdxVals( self, i : int ):\\n return range(self._layout.starts[i],self._layout.ends[i])\",\n \"def get_param_indexes(self):\\n self.debug.start_function('get_param_indexes')\\n\\n for i, key in enumerate(self.mcmc_version.param_keys):\\n self.param_idxs[key] = i\\n for i, key in enumerate(self.mcmc_version.interp_keys):\\n self.interp_idxs[key] = i\\n\\n self.debug.end_function()\",\n \"def vector(self,\\n i: int,\\n j: int) -> np.ndarray:\\n return self[j].coord - self[i].coord\",\n \"def jw_number_indices(n_electrons, n_qubits):\\n occupations = itertools.combinations(range(n_qubits), n_electrons)\\n indices = [sum([2**n for n in occupation]) for occupation in occupations]\\n return indices\",\n \"def _compute_indices(self):\\n self.indices = np.arange(len(self.im_filenames))\\n np.random.shuffle(self.indices)\",\n \"def computeIndices(org_center:tuple, rot_center:tuple, xyPairs, angle, org_box_offset:tuple):\\n rot_center = np.array([[rot_center[0]], [rot_center[1]]])\\n org_center = np.array([[org_center[0]], [org_center[1]]])\\n org_box_offset = np.array([[org_box_offset[0]], [org_box_offset[1]]])\\n newPairs = xyPairs - rot_center\\n\\n rotMatrix = buildRotationMatrix(angle)\\n\\n orgPairs = np.matmul(rotMatrix, newPairs)\\n\\n return np.array(orgPairs) + org_center + org_box_offset\",\n \"def indices(self, position=None):\\n \\n raise NotImplementedError()\",\n \"def ets(self):\\n r = (self.table[0, 0] + self.table[0, 1]) * (self.table[0, 0] + self.table[1, 0]) / self.N\\n return (self.table[0, 0] - r) / (self.table[0, 0] + self.table[0, 1] + self.table[1, 0] - r)\",\n \"def _get_permutated_segments_indices(\\n self, randomized: bool, random_state: Optional[np.random.mtrand.RandomState]\\n ) -> np.ndarray:\\n idx = np.arange(self.dy.size)\\n\\n if randomized:\\n if random_state is None:\\n random_state = np.random.RandomState()\\n idx = random_state.permutation(idx)\\n return idx\",\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 indices ( self, x1, y1, z1, x2, y2, z2 ):\\n xi1, yi1, zi1 = self.index(min(x1, x2), min(y1, y2), min(z1, z2))\\n xi2, yi2, zi2 = self.index(max(x1, x2), max(y1, y2), max(z1, z2))\\n return s_[xi1:xi2+1], s_[yi1:yi2+1], s_[zi1:zi2+1]\",\n \"def surface_indices(self):\\n return self._unique_surface_indices(self.surf_mesh)\",\n \"def getVectors(self):\\n vectors = dict()\\n i = 0\\n N = len(self.db.invertedIndex)\\n for w, (idf, docs) in self.db.invertedIndex.items():\\n for doc, tf in docs.items():\\n try:\\n vectors[doc][i] = tf * idf\\n except KeyError as k:\\n vectors[doc] = {i: tf * idf}\\n i += 1\\n i = 0;\\n return vectors\",\n \"def get_indices_input_target(num_obs, input_len, step_size, forecast_horizon, target_len):\\n input_len = round(input_len) # just a precaution\\n start_position = 0\\n stop_position = num_obs - 1\\n\\n inpseq_first_idx = start_position\\n inpseq_last_idx = inpseq_first_idx + input_len\\n target_first_idx = inpseq_last_idx + forecast_horizon\\n target_last_idx = target_first_idx + target_len\\n print(\\\"target_last_idx = {}\\\".format(target_last_idx))\\n print(\\\"stop_position = {}\\\".format(stop_position))\\n indices = []\\n while target_last_idx <= stop_position:\\n indices.append((inpseq_first_idx, inpseq_last_idx, target_first_idx, target_last_idx))\\n inpseq_first_idx += step_size\\n inpseq_last_idx += step_size\\n target_first_idx += inpseq_last_idx + forecast_horizon\\n target_last_idx += target_first_idx + target_len\\n return indices\",\n \"def hoggar_indices():\\n return list(product([0,1], repeat=6))\",\n \"def getIndices(self, tokens):\\n tokenTxt, posTxt = attachTokens(tokens)\\n if tokenTxt in self.tokenIndices:\\n tokenIdx = self.tokenIndices[tokenTxt]\\n else:\\n tokenIdx = self.tokenIndices[unk]\\n if posTxt in self.posIndices:\\n posIdx = self.posIndices[posTxt]\\n else:\\n posIdx = self.posIndices[unk]\\n return tokenIdx, posIdx\",\n \"def mesh_support_idx(self, j):\\n self._ensure_mesh()\\n supp = self.support_idx(j)\\n return (self._knots_to_mesh[supp[0]], self._knots_to_mesh[supp[1]])\",\n \"def _get_index(self):\\n\\n return self.index\\n\\n # to avoid having differences bigger than 2pi\",\n \"def _iter_indices(self, frame, y):\\n pass\",\n \"def indices(self):\\n return tuple([slice(*r) for r in self.location])\",\n \"def _get_block_indices(y):\\n block_labels, block_inv, block_sizes = np.unique(\\n y, return_inverse=True, return_counts=True\\n )\\n\\n n_blocks = len(block_labels)\\n block_inds = range(n_blocks)\\n\\n block_vert_inds = []\\n for i in block_inds:\\n # get the inds from the original graph\\n inds = np.where(block_inv == i)[0]\\n block_vert_inds.append(inds)\\n return block_vert_inds, block_inds, block_inv\",\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 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 index_to_obs(a,b, grid_x, grid_y):\\n position = grid_x[a]\\n velocity = grid_y[b]\\n return position, velocity\",\n \"def compute_positions(self):\\n return (self.x + DIRECTIONS[self.facing_direction][0]) % (self.image.shape[0] - 1), \\\\\\n (self.y + DIRECTIONS[self.facing_direction][1]) % (self.image.shape[1] - 1)\",\n \"def morton_idx(pts):\\n lib = _initlib()\\n p = require(pts, dtype=float64, requirements=['C']) \\n inv_cell_width = 1.0/8192\\n npts = len(p)\\n out = empty(npts, dtype=int64)\\n lib.get_morton_idx(p, npts, inv_cell_width, out)\\n return out\",\n \"def _extract_t_indices(self, X, X2=None, dL_dK=None):\\r\\n\\r\\n # TODO: some fast checking here to see if this needs recomputing?\\r\\n self._t = X[:, 0]\\r\\n if not X.shape[1] == 2:\\r\\n raise ValueError('Input matrix for ode1 covariance should have two columns, one containing times, the other output indices')\\r\\n self._index = np.asarray(X[:, 1],dtype=np.int)\\r\\n # Sort indices so that outputs are in blocks for computational\\r\\n # convenience.\\r\\n self._order = self._index.argsort()\\r\\n self._index = self._index[self._order]\\r\\n self._t = self._t[self._order]\\r\\n self._rorder = self._order.argsort() # rorder is for reversing the order\\r\\n \\r\\n if X2 is None:\\r\\n self._t2 = None\\r\\n self._index2 = None\\r\\n self._order2 = self._order\\r\\n self._rorder2 = self._rorder\\r\\n else:\\r\\n if not X2.shape[1] == 2:\\r\\n raise ValueError('Input matrix for ode1 covariance should have two columns, one containing times, the other output indices')\\r\\n self._t2 = X2[:, 0]\\r\\n self._index2 = np.asarray(X2[:, 1],dtype=np.int)\\r\\n self._order2 = self._index2.argsort()\\r\\n self._index2 = self._index2[self._order2]\\r\\n self._t2 = self._t2[self._order2]\\r\\n self._rorder2 = self._order2.argsort() # rorder2 is for reversing order\\r\\n\\r\\n if dL_dK is not None:\\r\\n self._dL_dK = dL_dK[self._order, :]\\r\\n self._dL_dK = self._dL_dK[:, self._order2]\",\n \"def getstate(self):\\r\\n return [self.tied_indices,\\r\\n self.fixed_indices,\\r\\n self.fixed_values,\\r\\n self.constrained_indices,\\r\\n self.constraints]\",\n \"def get_img_indices():\\n if K.image_dim_ordering() == 'th':\\n return 0, 1, 2, 3\\n else:\\n return 0, 3, 1, 2\",\n \"def _fixed_indicies(self):\\n fixed_inds = self.constraints == 'fixed'\\n return fixed_inds\",\n \"def create_vectors(self):\\n self.localStatistics = []\\n self.lastStatistics = []\\n self.globalV = []\\n self.estimate = []\\n self.delta = []\\n self.drift = []\\n self.slack = [] # only for coordBased model\",\n \"def test_y_vector_init(self):\\n # If you change the y-vector ordering, change here too #Y_VECTOR_CHANGESITE\\n\\n eng_fields = np.zeros(EngineeringState.N_ENGINEERING_FIELDS)\\n component_array = eng_fields[EngineeringState._COMPONENT_START_INDEX:EngineeringState._COMPONENT_END_INDEX]\\n for comp_i in range(0, N_COMPONENTS):\\n component_array[comp_i + N_COMPONENTS * 0] = True # connected\\n component_array[comp_i + N_COMPONENTS * 1] = 1 + (0.01 * comp_i) # capacity\\n component_array[comp_i + N_COMPONENTS * 2] = 222200 + comp_i # temperature\\n component_array[comp_i + N_COMPONENTS * 3] = comp_i % 2 # coolant_hab_one\\n component_array[comp_i + N_COMPONENTS * 4] = True # coolant_hab_two\\n component_array[comp_i + N_COMPONENTS * 5] = False # coolant_ayse\\n\\n coolant_array = eng_fields[EngineeringState._COOLANT_START_INDEX:EngineeringState._COOLANT_END_INDEX]\\n for cool_i in range(0, N_COOLANT_LOOPS):\\n coolant_array[cool_i + N_COOLANT_LOOPS * 0] = 555500 + cool_i # coolant_temp\\n coolant_array[cool_i + N_COOLANT_LOOPS * 1] = cool_i % 2 # primary_pump_on\\n coolant_array[cool_i + N_COOLANT_LOOPS * 2] = True # secondary_pump_on\\n\\n rad_array = eng_fields[EngineeringState._RADIATOR_START_INDEX:EngineeringState._RADIATOR_END_INDEX]\\n for rad_i in range(0, N_RADIATORS):\\n rad_array[rad_i + N_RADIATORS * 0] = rad_i % 4 # attached_to_coolant_loop\\n rad_array[rad_i + N_RADIATORS * 1] = rad_i % 2 # functioning\\n\\n y0 = np.concatenate((np.array([\\n 0x111, 0x222, # x\\n 0x333, 0x444, # y\\n 0x555, 0x777, # vx\\n 0x888, 0x999, # vy\\n 0.01, 0.02, # heading\\n 0.03, 0.04, # spin\\n 0xEEE, 0xFFF, # fuel\\n 5, 6, # throttle\\n 1, -1, # only First is landed on Second\\n 0, 1, # Second is broken\\n common.SRB_EMPTY,\\n 1 # time_acc\\n ]),\\n eng_fields\\n ))\\n\\n ps = PhysicsState(y0, self.proto_state)\\n self.assertTrue(np.array_equal(ps.y0(), y0.astype(ps.y0().dtype)))\\n self.assertEqual(ps['First'].landed_on, 'Second')\\n\\n proto_state = ps.as_proto()\\n proto_state.timestamp = 50\\n self.assertEqual(proto_state.entities[0].x, 0x111)\\n self.assertEqual(proto_state.entities[0].y, 0x333)\\n self.assertEqual(proto_state.entities[1].x, 0x222)\\n self.assertEqual(proto_state.entities[1].y, 0x444)\\n self.assertEqual(proto_state.entities[0].vx, 0x555)\\n self.assertEqual(proto_state.entities[0].vy, 0x888)\\n self.assertEqual(proto_state.entities[1].vx, 0x777)\\n self.assertEqual(proto_state.entities[1].vy, 0x999)\\n self.assertEqual(proto_state.entities[0].heading, 0.01)\\n self.assertEqual(proto_state.entities[1].heading, 0.02)\\n self.assertEqual(proto_state.entities[0].spin, 0.03)\\n self.assertEqual(proto_state.entities[1].spin, 0.04)\\n self.assertEqual(proto_state.entities[0].fuel, 0xEEE)\\n self.assertEqual(proto_state.entities[1].fuel, 0xFFF)\\n self.assertEqual(proto_state.entities[0].landed_on, 'Second')\\n self.assertEqual(proto_state.entities[1].landed_on, '')\\n self.assertEqual(proto_state.timestamp, 50)\\n self.assertTrue(proto_state.entities[1].broken)\\n\\n for i, component in enumerate(ps.engineering.components):\\n self.assertEqual(component.connected, True, msg=i)\\n self.assertEqual(component.capacity, 1 + (0.01 * i), msg=i)\\n self.assertEqual(component.temperature, 222200 + i, msg=i)\\n self.assertEqual(component.coolant_hab_one, bool(i % 2), msg=i)\\n self.assertEqual(component.coolant_hab_two, True, msg=i)\\n self.assertEqual(component.coolant_ayse, False, msg=i)\\n\\n for i, coolant in enumerate(ps.engineering.coolant_loops):\\n self.assertEqual(coolant.coolant_temp, 555500 + i, msg=i)\\n self.assertEqual(coolant.primary_pump_on, bool(i % 2), msg=i)\\n self.assertEqual(coolant.secondary_pump_on, True, msg=i)\\n\\n for i, radiator in enumerate(ps.engineering.radiators):\\n pass\\n self.assertEqual(radiator.attached_to_coolant_loop, i % 4, msg=i)\\n self.assertEqual(radiator.functioning, bool(i % 2), msg=i)\",\n \"def _get_block_indices(y: np.ndarray) -> Tuple[List[np.ndarray], range, np.ndarray]:\\n block_labels: np.ndarray\\n block_inv: np.ndarray\\n block_sizes: np.ndarray\\n block_labels, block_inv, block_sizes = np.unique(\\n y, return_inverse=True, return_counts=True\\n )\\n\\n n_blocks = len(block_labels)\\n block_inds = range(n_blocks)\\n\\n block_vert_inds = []\\n for i in block_inds:\\n # get the inds from the original graph\\n inds = np.where(block_inv == i)[0]\\n block_vert_inds.append(inds)\\n return block_vert_inds, block_inds, block_inv\",\n \"def expandcal(self):\\n ind=np.zeros(self.spec.shape[0]).astype(int)\\n for k in range(self.nscan):\\n ind[self.getscanind(k)]=k\\n ind[self.getcalind(k)]=k\\n return ind\",\n \"def velocities(self, return_np=False):\\n if return_np:\\n return self.si_values()[3:]\\n return [self.v_x, self.v_y, self.v_z]\",\n \"def min_indices(self):\\n return {term.minterm_index for term in self.iter_minterms()}\",\n \"def indices(self, _user=None):\\n return [p.index for p in self.get_active_smallvariant_cases()]\",\n \"def box_collision_info(self):\\r\\n position = np.zeros((self.Npart,3)) # antall part, dim, iterasjoner\\r\\n position[:,:] = np.random.uniform(0,1e-6, size = (self.Npart,3))\\r\\n velocity = np.zeros((self.Npart,3))\\r\\n velocity[:,:] = np.random.normal(0,self.sigma,size = (self.Npart,3))\\r\\n\\r\\n part_collided = 0\\r\\n part_escaped = 0\\r\\n momentum = 0\\r\\n\\r\\n print 'engine started'\\r\\n for i in xrange(1,self.n):\\r\\n #collision\\r\\n position += velocity*dt\\r\\n l_hole = position[:,0:2] > self.L/4\\r\\n h_hole = position[:,0:2] < (3*self.L)/4\\r\\n pos_xy = np.logical_and(l_hole, h_hole)\\r\\n pos_xy = np.logical_and(pos_xy[:,0], pos_xy[:,1])\\r\\n pos_z = position[:,2] < 0\\r\\n esc_part = np.logical_and(pos_z, pos_xy)\\r\\n\\r\\n #velocity[esc_part] = velocity[esc_part]\\r\\n part_escaped += np.sum(esc_part)\\r\\n\\r\\n for j in xrange(0,3):\\r\\n impact_wall_pos = np.logical_and(position[:,j] > 0,\\r\\n position[:,j] < self.L)\\r\\n velocity[np.logical_not(impact_wall_pos),j] = -velocity[\\r\\n np.logical_not(impact_wall_pos),j]\\r\\n\\r\\n\\r\\n if j == 0:\\r\\n part_collided += np.sum(np.logical_not(impact_wall_pos),j)\\r\\n momentum += np.sum(2*self.m*abs(velocity[np.logical_not(\\r\\n impact_wall_pos),j]))\\r\\n\\r\\n\\r\\n\\r\\n position[position < 0] = 0\\r\\n position[position >self.L] = self.L\\r\\n\\r\\n particle_collided = part_collided/2\\r\\n return position, velocity,part_escaped, impact_wall_pos, particle_collided, momentum\",\n \"def get_indexes(self):\\n indexes = []\\n for c in self.components:\\n indexes.extend(c.get_indexes())\\n return indexes\",\n \"def vector(molec, dihed, nonH, energy):\\n #Torison\\n if dihed:\\n pass\\n #XYZ\\n else:\\n coords = ()\\n if nonH:\\n for atom in molec.atoms:\\n coords += atom.coords\\n else:\\n for atom in molec.atoms:\\n if atom.atomicnum > 1:\\n coords += atom.coords\\n #Energy\\n if energy:\\n coords += (molec.energy/10.0,)\\n return coords\",\n \"def get_final_pruned_indices(self):\\n return self.final_pruned_indices\",\n \"def calculate_useful_stuff(self):\\n\\n self.pos = self.pair[1].position - self.pair[0].position\\n self.vel = self.pair[1].velocity - self.pair[0].velocity\\n\\n self.r = self.pos.length()\\n self.v = self.vel.length()\\n self.inv_r = 1.0 / self.r\\n\\n self.rvec = self.pos * self.inv_r\\n self.rdot = (self.rvec * self.vel).sum() * self.rvec\\n self.rdot_mag = self.rdot.length()\\n\\n self.vth = self.vel - self.rdot\\n self.vth_mag = self.vth.length()\\n self.vth_vec = self.vth / self.vth_mag\",\n \"def velocity_field(self):\\n return scipy.dstack((self._u_int, self._v_int))\",\n \"def get_segment_index(datadb):\\n #match in time!!!!\\n if cfg.use_saliency:\\n segment_index_tar = util.get_time_for_visual(datadb)\\n segment_index_tar_future = OrderedDict()\\n for key in segment_index_tar.keys():\\n segment_index_tar_future[key] = np.array(segment_index_tar[key])+max_encoder_seq_length\\n return segment_index_tar,segment_index_tar_future\",\n \"def get_ecc(self):\\n mu_mass = G*(self._mm + self._sm)\\n h_mom = self.sp_ang_mom()\\n vel = self.getvel_xyz()\\n pos = self.getpos_xyz()\\n e_vec = 1.0/mu_mass*(np.cross(vel, h_mom) -\\n mu_mass*pos/np.linalg.norm(pos))\\n return e_vec\",\n \"def calc_index(self, x, y, model, variable, weights=None, time_weighting=True):\\n\\n if weights is None:\\n # set weights according to cell area\\n if x.cell_area is not None:\\n weights = x._get_weighting_matrix()\\n else:\\n print('WARNING: no weights when calculating performance index')\\n weights = np.ones(x.data.shape)\\n else: # weights are given\\n if x.cell_area is not None:\\n print('WARNING: cell weights are given, while cell_area available from data!!')\\n\\n from pycmbs.diagnostic import Diagnostic\\n D = Diagnostic(x, y=y)\\n # reichler performance index\\n # (might return a list if multiple times analyzed)\\n e2 = D.calc_reichler_index(weights) # returns [time, index]\\n if e2 is not None:\\n e2 = np.ma.masked_where(np.isnan(e2), e2)\\n\\n # Note that the returned value is E**2 for each timestep!\\n # When doing the normalization, one needs to take the sqrt(E++2)\\n # to obtain the actual RMSE\\n if e2 is None:\\n return None\\n else:\\n if time_weighting:\\n days = np.asarray(x._days_per_month()) # number of days for each month\\n wt = days / float(days.sum()) # weights for time\\n else:\\n wt = np.ones(len(e2)) / float(len(e2))\\n\\n return np.sqrt((e2 * wt).sum())\",\n \"def get_uncut_indices(atoms, orig, vec1, offset=None):\\n\\n if isinstance(orig, int):\\n orig = atoms.get_positions()[orig]\\n else:\\n orig = np.array(orig)\\n if isinstance(vec1, int):\\n vec1 = atoms.get_positions()[vec1]\\n else:\\n vec1 = np.array(vec1)\\n\\n# if vec2 and isinstance(vec2, int):\\n# vec2 = atoms.get_positions()[vec2]\\n# elif vec2:\\n# vec2 = np.array(vec2)\\n# if vec3 and isinstance(vec3, int):\\n# vec3 = atoms.get_positions()[vec3]\\n# elif vec3:\\n# vec3 = np.array(vec3)\\n#\\n# if vec2:\\n# plane_vec = np.cross(vec1-orig, vec2-orig)\\n# else:\\n# plane_vec = vec1-orig\\n#\\n# nplane_vec = plane_vec/np.linalg.norm(plane_vec)\\n#\\n# if vec2 and vec3 and nplane_vec.dot(vec3-orig) < 0:\\n# nplane_vec *= -1\\n\\n plane_vec = vec1 - orig\\n nplane_vec = plane_vec/np.linalg.norm(plane_vec)\\n\\n if offset:\\n orig += offset*nplane_vec\\n\\n atom_indices = [i for i,a in enumerate(atoms) if (a.position - orig).dot(nplane_vec) > 0]\\n return atom_indices\",\n \"def _index(self, i, j):\\n assert self._isvalid(i), 'i term (%s) is out of bounds' % i\\n assert self._isvalid(j), 'j term (%s) is out of bounds' % j\\n\\n return self.n * (i - 1) + (j - 1)\",\n \"def compute_idx(pos, edge_index):\\n\\n pos_i = pos[edge_index[0]]\\n pos_j = pos[edge_index[1]]\\n\\n d_ij = torch.norm(abs(pos_j - pos_i), dim=-1, keepdim=False).unsqueeze(-1) + 1e-5\\n v_ji = (pos_i - pos_j) / d_ij\\n\\n unique, counts = torch.unique(\\n edge_index[0], sorted=True, return_counts=True\\n ) # Get central values\\n full_index = (\\n torch.arange(0, edge_index[0].size()[0]).cuda().int()\\n ) # init full index\\n\\n # Compute 1\\n repeat = torch.repeat_interleave(counts, counts)\\n counts_repeat1 = torch.repeat_interleave(full_index, repeat) # 0,...,0,1,...,1,...\\n\\n # Compute 2\\n split = torch.split(full_index, counts.tolist()) # split full index\\n index2 = list(edge_index[0].data.cpu().numpy()) # get repeat index\\n counts_repeat2 = torch.cat(itemgetter(*index2)(split), dim=0) # 0,1,2,...,0,1,2,..\\n\\n # Compute angle embeddings\\n v1 = v_ji[counts_repeat1.long()]\\n v2 = v_ji[counts_repeat2.long()]\\n\\n angle = (v1 * v2).sum(-1).unsqueeze(-1)\\n angle = torch.clamp(angle, min=-1.0, max=1.0) + 1e-6 + 1.0\\n\\n return counts_repeat1.long(), counts_repeat2.long(), angle\",\n \"def _getitem2d(self, index):\\n\\n lovects = self._getlovects()\\n hivects = self._gethivects()\\n fields = self._getfields()\\n\\n ix = index[0]\\n iz = index[1]\\n\\n if len(fields[0].shape) > self.dim:\\n ncomps = fields[0].shape[-1]\\n else:\\n ncomps = 1\\n\\n if len(index) > self.dim:\\n if ncomps > 1:\\n ic = index[2]\\n else:\\n raise Exception('Too many indices given')\\n else:\\n ic = None\\n\\n nx = hivects[0,:].max() - self.nghosts\\n nz = hivects[1,:].max() - self.nghosts\\n\\n if npes > 1:\\n nx = comm_world.allreduce(nx, op=mpi.MAX)\\n nz = comm_world.allreduce(nz, op=mpi.MAX)\\n\\n if isinstance(ix, slice):\\n ixstart = max(ix.start or -self.nghosts, -self.nghosts)\\n ixstop = min(ix.stop or nx + 1 + self.nghosts, nx + self.overlaps[0] + self.nghosts)\\n else:\\n ixstart = ix\\n ixstop = ix + 1\\n if isinstance(iz, slice):\\n izstart = max(iz.start or -self.nghosts, -self.nghosts)\\n izstop = min(iz.stop or nz + 1 + self.nghosts, nz + self.overlaps[1] + self.nghosts)\\n else:\\n izstart = iz\\n izstop = iz + 1\\n\\n # --- Setup the size of the array to be returned and create it.\\n # --- Space is added for multiple components if needed.\\n sss = (max(0, ixstop - ixstart),\\n max(0, izstop - izstart))\\n if ncomps > 1 and ic is None:\\n sss = tuple(list(sss) + [ncomps])\\n resultglobal = np.zeros(sss, dtype=_libwarpx._numpy_real_dtype)\\n\\n datalist = []\\n for i in range(len(fields)):\\n\\n # --- The ix1, 2 etc are relative to global indexing\\n ix1 = max(ixstart, lovects[0,i])\\n ix2 = min(ixstop, lovects[0,i] + fields[i].shape[0])\\n iz1 = max(izstart, lovects[1,i])\\n iz2 = min(izstop, lovects[1,i] + fields[i].shape[1])\\n\\n if ix1 < ix2 and iz1 < iz2:\\n\\n sss = (slice(ix1 - lovects[0,i], ix2 - lovects[0,i]),\\n slice(iz1 - lovects[1,i], iz2 - lovects[1,i]))\\n if ic is not None:\\n sss = tuple(list(sss) + [ic])\\n\\n vslice = (slice(ix1 - ixstart, ix2 - ixstart),\\n slice(iz1 - izstart, iz2 - izstart))\\n\\n datalist.append((vslice, fields[i][sss]))\\n\\n if npes == 1:\\n all_datalist = [datalist]\\n else:\\n all_datalist = comm_world.allgather(datalist)\\n\\n for datalist in all_datalist:\\n for vslice, ff in datalist:\\n resultglobal[vslice] = ff\\n\\n # --- Now remove any of the reduced dimensions.\\n sss = [slice(None), slice(None)]\\n if not isinstance(ix, slice):\\n sss[0] = 0\\n if not isinstance(iz, slice):\\n sss[1] = 0\\n\\n return resultglobal[tuple(sss)]\",\n \"def agent_locs_idx(self):\\n return tuple(self.agent_locs.T)\",\n \"def _position_and_velocity(self, jd):\\n pos, vel = terra(self.latitude.radians, self.longitude.radians,\\n self.elevation.au, jd.gast)\\n pos = einsum('ij...,j...->i...', jd.MT, pos)\\n vel = einsum('ij...,j...->i...', jd.MT, vel)\\n return pos, vel\",\n \"def indices_hkl(self, H, K, L):\\n from cctbx import miller\\n _symm_equiv = miller.sym_equiv_indices(self.sg, (H, K, L))\\n _indices = sorted([i.h() for i in _symm_equiv.indices()],\\n reverse=True)\\n if len(_indices) < _symm_equiv.multiplicity(False):\\n _indices = _indices + [(-hh, -kk, -ll)\\n for (hh, kk, ll) in _indices]\\n return _indices\",\n \"def get_analytical_accelerations(self):\\n # create empty numpy array for accelerations\\n accelerations = np.zeros((3, len(self.times)))\\n # radial accelerations is equal to angular velocity^2 / radius but radius is unitary is this trajectory\\n radial_acceleration = self.wz ** 2\\n # decompose radial accelerations in x and y components\\n accelerations[0, :] = radial_acceleration * -cos(self.th[:, 2])\\n accelerations[1, :] = radial_acceleration * -sin(self.th[:, 2])\\n # accelerations along x axis is constant\\n accelerations[2, :] = self.ax\\n return accelerations\",\n \"def _get_valid_indices(\\n self,\\n _signals: np.ndarray,\\n _labels: np.ndarray,\\n window_start_indices: np.ndarray = None,\\n elm_start_indices: np.ndarray = None,\\n elm_stop_indices: np.ndarray = None,\\n valid_t0: np.ndarray = None,\\n labels: np.ndarray = None,\\n signals: np.ndarray = None,\\n ) -> Tuple[\\n np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray\\n ]:\\n # allowed indices; time data points which can be used for creating the data chunks\\n _valid_t0 = np.ones(_labels.shape, dtype=np.int32)\\n _valid_t0[\\n -(config.signal_window_size + config.label_look_ahead) + 1 :\\n ] = 0\\n\\n # indices for active elm events in each elm event\\n active_elm_events = np.nonzero(_labels >= 0.5)[0]\\n\\n if signals is None:\\n # initialize arrays\\n window_start_indices = np.array([0])\\n elm_start_indices = active_elm_events[0]\\n elm_stop_indices = active_elm_events[-1]\\n valid_t0 = _valid_t0\\n signals = _signals\\n labels = _labels\\n else:\\n # concat on axis 0 (time dimension)\\n last_index = len(labels) - 1\\n window_start_indices = np.append(\\n window_start_indices, last_index + 1\\n )\\n elm_start_indices = np.append(\\n elm_start_indices, active_elm_events[0] + last_index + 1\\n )\\n elm_stop_indices = np.append(\\n elm_stop_indices, active_elm_events[-1] + last_index + 1\\n )\\n valid_t0 = np.concatenate([valid_t0, _valid_t0])\\n signals = np.concatenate([signals, _signals], axis=0)\\n labels = np.concatenate([labels, _labels], axis=0)\\n\\n return (\\n signals,\\n labels,\\n valid_t0,\\n window_start_indices,\\n elm_start_indices,\\n elm_stop_indices,\\n )\",\n \"def cal_globalIndexH(self):\\n h_local = self.cal_localIndexH()\\n h_global = np.sum(h_local)\\n\\n return h_global\",\n \"def indices(self):\\n if self._indices is None:\\n i = []\\n\\n # TODO: this is not right for multi-column keys\\n # TODO: new style indexes\\n\\n global_name = '^DD(%s,0,\\\"IX\\\",\\\"0\\\")' % self.fileid\\n prefix = '^DD(%s,0,\\\"IX\\\",' % self.fileid\\n while 1:\\n global_name = M.mexec('set s0=$query(%s)' % global_name, M.INOUT(\\\"\\\"))[0]\\n if not global_name or not global_name.startswith(prefix):\\n break\\n suffix = global_name[len(prefix):-1]\\n parts = suffix.split(\\\",\\\")\\n idx_name = parts[0][1:-1]\\n idx_table = parts[1]\\n idx_columns = parts[2:]\\n index = Index(idx_name, idx_table, idx_columns)\\n i.append(index)\\n\\n # A second list, gives indices for a field\\n columns = {}\\n for idx in i:\\n for c in idx.columns:\\n columns[c] = 1\\n\\n # Now trawl the listed columns in the data dictionary, and load their\\n # cross references.\\n cr_names = {}\\n for c in columns.keys():\\n idx_root = M.Globals[\\\"^DD\\\"][self.fileid][c][1]\\n if not idx_root[0].exists():\\n continue\\n for cr_id, val in idx_root.keys_with_decendants():\\n if float(cr_id) > 0:\\n cr_header = idx_root[cr_id][0].value\\n parts = cr_header.split(\\\"^\\\")\\n if len(parts) == 2 and parts[1]: # if more than 2 parts, assume MUMPs trigger\\n f = cr_names.get(parts[1], list())\\n f.append(c)\\n cr_names[parts[1]] = f\\n\\n # Now, just delete items from the index list if they are not in cr_names\\n self._indices = []\\n for index in i:\\n cr = cr_names.get(index.name)\\n if cr:\\n # verify columns - lots of errors in real systems\\n if len(cr) == len(index.columns):\\n invalid = False\\n for c in cr:\\n if c not in index.columns:\\n invalid = True\\n continue\\n if not invalid:\\n self._indices.append(index)\\n\\n return self._indices\",\n \"def calcAllIntensities(self, xc, yc):\\n\\n tp = 0.0\\n ix = 0\\n iy = 0\\n h = 0\\n ints = np.zeros([5, 5])\\n ints_inner = np.zeros([5, 5])\\n # ints = [[0.0] * 5] * 5\\n # ints_inner = [[0.0] * 5] * 5\\n x = 0.0\\n y = 0.0\\n xc1 = 0.0\\n yc1 = 0.0\\n xc1 = xc\\n yc1 = yc\\n \\n for h in np.arange(1,5,1):\\n for k in np.arange(1,5,1):\\n ints[h][k] = 0.0\\n ints_inner[h][k] = 0.0\\n\\n for k in np.arange(0, 2, 1):\\n for h in np.arange(0, 2, 1):\\n for ix in np.arange(0, self.stepp + 1, 1):\\n for iy in np.arange(0, self.stepp + 1, 1):\\n #print(k, h, ix, iy)\\n if self.qc_format == 0 :\\n x = -(1 + self.G) + h * (1 + 2 * self.G) + (ix * (1.0 / self.stepp))\\n y = -(1 + self.G) + k * (1 + 2 * self.G) + (iy * (1.0 / self.stepp))\\n if self.spot_radius == 0 or math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)) == 0 :\\n tp = 0.0\\n else :\\n tp = (math.sin((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))) / ((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))\\n tp = math.pow(tp,2)\\n #print(tp)\\n elif self.qc_format == 1 :\\n x = -1 + h + (ix * (1 / self.stepp))\\n y = -1 + k + (iy * (1 / self.stepp))\\n ints[h + 1][k + 1] += math.pow(math.exp((math.pow((x - xc1),2) + math.pow((y - yc1),2) ) / math.pow(self.spot_radius,2)), -1)\\n if (self.spot_radius * self.spot_radius) == 0 or ((x - xc1) * (y - yc1) * np.pi * np.pi) == 0 :\\n tp = 0.0\\n else :\\n tp = (math.sin((x - xc1) * np.pi / self.spot_radius) * math.sin((y - yc1) * np.pi / self.spot_radius)) / (((x - xc1) * (y - yc1) * np.pi * np.pi) / (self.spot_radius * self.spot_radius))\\n\\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.radius_inner,2):\\n ints_inner[h + 1][k + 1] += tp\\n else :\\n if self.qc_format == 1 :\\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.cell_qc, 2):\\n ints[h + 1][k + 1] += tp\\n if (math.pow(x,2) + math.pow(y,2)) <= 1 :\\n #print(math.pow(x,2) + math.pow(y,2))\\n ints[h + 1][k + 1] += tp\\n # print(ints[h + 1][k + 1])\\t\\t\\t\\t\\t\\t\\n tp = 0.0\\n\\n # print(ints)\\n\\n Aq = 0.0\\n Bq = 0.0\\n Cq = 0.0\\n Dq = 0.0\\n Ac_inner = 0.0\\n Bc_inner = 0.0\\n Cc_inner = 0.0\\n Dc_inner = 0.0\\n Ac = 0.0\\n Bc = 0.0\\n Cc = 0.0\\n Dc = 0.0\\n Ac = ints[1][2]\\n Bc = ints[2][2]\\n Cc = ints[2][1]\\n Dc = ints[1][1]\\n\\n Ac_inner = ints_inner[1][2]\\n Bc_inner = ints_inner[2][2]\\n Cc_inner = ints_inner[2][1]\\n Dc_inner = ints_inner[1][1]\\n Ac *= self.QE\\n Bc *= self.QE\\n Cc *= self.QE\\n Dc *= self.QE\\n\\n Ac_inner *= self.QE_inner\\n Bc_inner *= self.QE_inner\\n Cc_inner *= self.QE_inner\\n Dc_inner *= self.QE_inner\\n Ac += Ac_inner\\n Bc += Bc_inner\\n Cc += Cc_inner\\n Dc += Dc_inner\\n\\n Aq = Ac\\n Bq = Bc\\n Cq = Cc\\n Dq = Dc\\n\\n #tp/TP = cotribution percentage of the spot with respect to max (spot center)\\n if self.smooth == 0 :\\n if (Config.hplk_c0_e * self.TP) == 0 :\\n cnst = 0\\n else :\\n cnst = ((Parameters.TPS / (self.n_ml * self.n_ml)) * self.lamb) / (Config.hplk_c0_e * self.TP) #Número de fótons efeticos\\n if Config.flag_spice == 1 :\\n Ac *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP) #W\\n Bc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\\n Cc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\\n Dc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\\n Ac *= 1 / (math.pow(self.cell_qc * 1e-6,2)) #W/(m^2)\\n Bc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\\n Cc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\\n Dc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\\n #Ac *= 1 / (self.lamb * 1e6); #Adequação da irradiância para a unidade W/m2micm conforme necessário no SPICE\\n #Bc *= 1 / (self.lamb * 1e6);\\n #Cc *= 1 / (self.lamb * 1e6);\\n #Dc *= 1 / (self.lamb * 1e6);\\n \\n ############################## DOUBLE CHECK ##############################\\n # self.grava_arquivos = 1\\n # self.flag_V_QC = 0\\n # grava_le_arquivos(0) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\\n # self.flag_V_QC = 1\\n # self.grava_arquivos = 0\\n ############################## DOUBLE CHECK ##############################\\n Aq *= cnst * 1e9\\n Bq *= cnst * 1e9\\n Cq *= cnst * 1e9\\n Dq *= cnst * 1e9\\n else :\\n Aq *= cnst * 1e9\\n Bq *= cnst * 1e9\\n Cq *= cnst * 1e9\\n Dq *= cnst * 1e9\\n\\n # 'returns' all the intensities\\n self.A_intensity = Aq\\n self.B_intensity = Bq\\n self.C_intensity = Cq\\n self.D_intensity = Dq\",\n \"def atom_idxs(self):\\n\\n return np.array([atom.atom_idxs for atom in self])\",\n \"def crearIndices(self):\\n l = self.encontrarCaracteres()\\n i=0\\n for c in l:\\n self.indices[c] = i\\n i+=1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70425975","0.6227534","0.621245","0.61198896","0.6050179","0.60492086","0.59963256","0.59747845","0.5971784","0.5960889","0.5925465","0.5918824","0.5916217","0.5899766","0.5848567","0.5788059","0.5782234","0.5770706","0.5726879","0.5722692","0.5709878","0.5705728","0.5678939","0.5640984","0.5640419","0.5631342","0.5630303","0.56163704","0.55861324","0.55519974","0.5551183","0.55342984","0.55268997","0.55034244","0.54960686","0.54851276","0.54804283","0.54672045","0.54626197","0.5453842","0.5436701","0.54277575","0.5420072","0.5420071","0.5402086","0.5392326","0.53901404","0.5388624","0.53812534","0.53764254","0.5366359","0.53615344","0.5357011","0.5334793","0.5325488","0.5317872","0.5317858","0.53114384","0.5310661","0.5300275","0.52820843","0.5279397","0.5275549","0.5270516","0.5268178","0.5264593","0.52638525","0.52607495","0.5260732","0.52568746","0.52547526","0.525471","0.525142","0.525029","0.5249663","0.52496094","0.5248935","0.5228188","0.5226314","0.52187985","0.5218281","0.5217674","0.5206792","0.52056205","0.5193406","0.5192475","0.5186248","0.51860255","0.51827234","0.5180917","0.5180642","0.51799184","0.5179198","0.5176682","0.51688766","0.5163929","0.51629454","0.5161684","0.5153994","0.5152692","0.51501006"],"string":"[\n \"0.70425975\",\n \"0.6227534\",\n \"0.621245\",\n \"0.61198896\",\n \"0.6050179\",\n \"0.60492086\",\n \"0.59963256\",\n \"0.59747845\",\n \"0.5971784\",\n \"0.5960889\",\n \"0.5925465\",\n \"0.5918824\",\n \"0.5916217\",\n \"0.5899766\",\n \"0.5848567\",\n \"0.5788059\",\n \"0.5782234\",\n \"0.5770706\",\n \"0.5726879\",\n \"0.5722692\",\n \"0.5709878\",\n \"0.5705728\",\n \"0.5678939\",\n \"0.5640984\",\n \"0.5640419\",\n \"0.5631342\",\n \"0.5630303\",\n \"0.56163704\",\n \"0.55861324\",\n \"0.55519974\",\n \"0.5551183\",\n \"0.55342984\",\n \"0.55268997\",\n \"0.55034244\",\n \"0.54960686\",\n \"0.54851276\",\n \"0.54804283\",\n \"0.54672045\",\n \"0.54626197\",\n \"0.5453842\",\n \"0.5436701\",\n \"0.54277575\",\n \"0.5420072\",\n \"0.5420071\",\n \"0.5402086\",\n \"0.5392326\",\n \"0.53901404\",\n \"0.5388624\",\n \"0.53812534\",\n \"0.53764254\",\n \"0.5366359\",\n \"0.53615344\",\n \"0.5357011\",\n \"0.5334793\",\n \"0.5325488\",\n \"0.5317872\",\n \"0.5317858\",\n \"0.53114384\",\n \"0.5310661\",\n \"0.5300275\",\n \"0.52820843\",\n \"0.5279397\",\n \"0.5275549\",\n \"0.5270516\",\n \"0.5268178\",\n \"0.5264593\",\n \"0.52638525\",\n \"0.52607495\",\n \"0.5260732\",\n \"0.52568746\",\n \"0.52547526\",\n \"0.525471\",\n \"0.525142\",\n \"0.525029\",\n \"0.5249663\",\n \"0.52496094\",\n \"0.5248935\",\n \"0.5228188\",\n \"0.5226314\",\n \"0.52187985\",\n \"0.5218281\",\n \"0.5217674\",\n \"0.5206792\",\n \"0.52056205\",\n \"0.5193406\",\n \"0.5192475\",\n \"0.5186248\",\n \"0.51860255\",\n \"0.51827234\",\n \"0.5180917\",\n \"0.5180642\",\n \"0.51799184\",\n \"0.5179198\",\n \"0.5176682\",\n \"0.51688766\",\n \"0.5163929\",\n \"0.51629454\",\n \"0.5161684\",\n \"0.5153994\",\n \"0.5152692\",\n \"0.51501006\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":87193,"cells":{"query":{"kind":"string","value":"Compute and set the additional terms to fix the boundary values."},"document":{"kind":"string","value":"def set_rhs(self):\n k = self.istore[:, 0]\n ksym = self.stencil.get_symmetric()[k]\n self.rhs[:] = self.feq[k, np.arange(k.size)] - self.feq[ksym, np.arange(k.size)]"},"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 calculateElementBoundaryCoefficients(self):\n pass","def update(self):\n\n terms_toRemove = []\n\n for termIndex, [term_constantFactor, term_unknowns_attributeAddresses] in enumerate(self.LHS):\n\n # Check if coefficient is 0 - then no need to process any of the unknowns since term will be 0 anyways\n if term_constantFactor == 0:\n terms_toRemove.append(termIndex)\n continue # continue to next term, no need to resolve the unknowns of this term since the product will be 0 anyways\n\n # Check if any unknowns became known\n unknowns_toRemove = []\n for unknown_attributeAddress in term_unknowns_attributeAddresses:\n attribute = getattr_fromAddress(*unknown_attributeAddress)\n if isNumeric(attribute):\n # object.attribute which had previously been identified as unknown now has a value, add it to the constant factor product and remove from the unknowns\n self.LHS[termIndex][0] *= attribute # multiply it with the constant factor product\n unknowns_toRemove.append([termIndex, unknown_attributeAddress])\n for termIndex, unknown_attributeAddress in unknowns_toRemove: # remove unknowns which have become known in the end\n # removing in the end not to tamper with the iteration of the above loop\n self.LHS[termIndex][1].remove(unknown_attributeAddress)\n\n # Move constants to RHS\n if self.LHS[termIndex][1] == []:\n # if term has no unknowns, it is a constant, move to RHS\n self.RHS -= self.LHS[termIndex][0]\n self.LHS.pop(termIndex)\n\n for termIndex in reversed(terms_toRemove): # reversed - otherwise would tamper with indices of items identified for removal\n self.LHS.pop(termIndex)\n\n self._gatherUnknowns()","def boundary_conditions(self):\n ce = 2 * self.dy * self.g * self.mu * self.m_u / self.kb\n self.e[0, :] = (4 * self.e[1, :] - self.e[2, :]) / (\n ce / self.T[0, :] + 3\n )\n self.rho[0, :] = (\n self.e[0, :]\n * (self.Y - 1)\n * self.mu\n * self.m_u\n / (self.kb * self.T[0, :])\n )\n self.u[0, :] = (4 * self.u[1, :] - self.u[2, :]) / 3\n self.w[0, :] = 0\n\n self.e[-1, :] = (4 * self.e[-2, :] - self.e[-3, :]) / (\n 3 - ce / self.T[-1, :]\n )\n self.rho[-1, :] = (\n self.e[-1, :]\n * (self.Y - 1)\n * self.mu\n * self.m_u\n / (self.kb * self.T[-1, :])\n )\n self.u[-1, :] = (4 * self.u[-2, :] - self.u[-3, :]) / 3\n self.w[-1, :] = 0","def set_internal_boundary_conditions(self, model):\n\n def boundary_gradient(left_symbol, right_symbol):\n pybamm.logger.debug(\n \"Calculate boundary gradient ({} and {})\".format(\n left_symbol, right_symbol\n )\n )\n left_domain = left_symbol.domain[0]\n right_domain = right_symbol.domain[0]\n\n left_mesh = self.spatial_methods[left_domain].mesh[left_domain]\n right_mesh = self.spatial_methods[right_domain].mesh[right_domain]\n\n left_symbol_disc = self.process_symbol(left_symbol)\n right_symbol_disc = self.process_symbol(right_symbol)\n\n return self.spatial_methods[left_domain].internal_neumann_condition(\n left_symbol_disc, right_symbol_disc, left_mesh, right_mesh\n )\n\n bc_keys = list(self.bcs.keys())\n\n internal_bcs = {}\n for var in model.boundary_conditions.keys():\n if isinstance(var, pybamm.Concatenation):\n children = var.orphans\n\n first_child = children[0]\n next_child = children[1]\n\n lbc = self.bcs[var][\"left\"]\n rbc = (boundary_gradient(first_child, next_child), \"Neumann\")\n\n if first_child not in bc_keys:\n internal_bcs.update({first_child: {\"left\": lbc, \"right\": rbc}})\n\n for current_child, next_child in zip(children[1:-1], children[2:]):\n lbc = rbc\n rbc = (boundary_gradient(current_child, next_child), \"Neumann\")\n if current_child not in bc_keys:\n internal_bcs.update(\n {current_child: {\"left\": lbc, \"right\": rbc}}\n )\n\n lbc = rbc\n rbc = self.bcs[var][\"right\"]\n if children[-1] not in bc_keys:\n internal_bcs.update({children[-1]: {\"left\": lbc, \"right\": rbc}})\n\n self.bcs.update(internal_bcs)","def apply_boundary_conditions(self):\n E = self.__mesh.get_edge_list()\n\n # Top and bottom wall Dirichlet bcs (boundary_id = 21)\n \n e21_iterator = self.__mesh.edge_iterator(21)\n\n self.edge_center_value[e21_iterator[0]:e21_iterator[1]+1] = 0.0 \n \n # Left Dirichlet bc (boundary_id = 2)\n \n e2_iterator = self.__mesh.edge_iterator(2)\n\n b = np.sin(np.pi*self.y_e[e2_iterator[0]:e2_iterator[1]+1])\n\n self.edge_center_value[e2_iterator[0]:e2_iterator[1]+1] \\\n = b\n \n # Right Neumann bc (Zero flux, boundary_id = 3)\n \n e3_iterator = self.__mesh.edge_iterator(3)\n \n for i in range(e3_iterator[0], e3_iterator[1]+1):\n LC = E[i].get_straddling_cells()\n n = LC.get_global_cell_number() - 1\n self.edge_center_value[i] = self.cell_centroid_value[n]","def increase_right_boundary(self):\n self.R = self.R + 1.0\n self.Ne = self.Ne + 1","def _add_boundaries(self):\n logger.info(\"add_boundaries: start of method\")\n\n import scipy.spatial as sptl\n import scipy.sparse as sprs\n Lx = self._Lx\n Ly = self._Ly\n Lz = self._Lz\n Np = self.num_pores()\n btype = self._btype\n boffset = 0.05\n\n #Translate internal pores to each face of domain\n poffset = np.zeros((7,3))\n poffset[[2,5],0] = [-Lx, Lx]\n poffset[[3,4],1] = [-Ly, Ly]\n poffset[[1,6],2] = [-Lz, Lz]\n pcoords = pcoords0 = self['pore.coords']\n for i in np.r_[1:7]:\n pcoords = np.concatenate((pcoords,pcoords0 + poffset[i,:]),axis=0)\n\n #Use some twisted logic to get bval list of + for boundary and - for periodic faces\n bval = [0, 1, 2, 3, 4, 5, 6]*(np.array([0, btype[2], btype[0], btype[1], btype[1], btype[0], btype[2]])*-2+1)\n ptype = np.zeros((Np,),dtype=int)\n for i in np.r_[1:7]:\n ptype = np.concatenate((ptype,np.ones((Np,),dtype=int)*bval[i]),axis=0)\n\n #pnum contains the internal ID number of the boundary pores (for connecting periodic points)\n pnum = self.pores()\n pnum = np.tile(pnum,7)\n\n Tri = sptl.Delaunay(pcoords)\n adjmat = sprs.lil_matrix((np.shape(pcoords)[0],np.shape(pcoords)[0]),dtype=int)\n for i in np.arange(0,np.shape(Tri.simplices)[0]):\n #Keep only simplices that are fully in real domain\n adjmat[Tri.simplices[i],Tri.simplices[i]] = 1\n adjmat = sprs.triu(adjmat,k=1,format=\"lil\")\n for i in np.arange(0,Np):\n #Add periodic throats to the netowrk (if any)\n tpore2 = pnum[adjmat.rows[i]][ptype[adjmat.rows[i]]<0]\n tpore1 = np.ones_like(tpore2,dtype=int)*i\n conns = self['throat.conns']\n conns = np.concatenate((conns,np.vstack((tpore1,tpore2)).T),axis=0)\n #Add boundary pores and throats to the network\n newporetyps = np.unique(ptype[adjmat.rows[i]][ptype[adjmat.rows[i]]>0])\n newporenums = np.r_[self.num_pores():self.num_pores()+np.size(newporetyps)]\n tpore2 = newporenums\n tpore1 = np.ones_like(tpore2,dtype=int)*i\n conns = np.concatenate((conns,np.vstack((tpore1,tpore2)).T),axis=0)\n self['throat.conns'] = conns\n bcoords = np.zeros((7,3),dtype=float)\n coords = self['pore.coords']\n bcoords[1,:] = [coords[i,0], coords[i,1], 0-Lz*boffset]\n bcoords[2,:] = [0-Lx*boffset, coords[i,1], coords[i,2]]\n bcoords[3,:] = [coords[i,0], -Ly*boffset, coords[i,2]]\n bcoords[4,:] = [coords[i,0], Ly+Ly*boffset, coords[i,2]]\n bcoords[5,:] = [Lx+Lx*boffset, coords[i,1], coords[i,2]]\n bcoords[6,:] = [coords[i,0], coords[i,1], Lz+Lz*boffset]\n newporecoords = bcoords[newporetyps,:]\n coords = np.concatenate((coords,newporecoords),axis=0)\n self['pore.coords'] = coords\n #Reset number of pores and throats (easier than tracking it)\n nums = np.r_[0:np.shape(coords)[0]]\n self['pore.numbering'] = nums\n self['pore.numbering'] = np.ones((nums[-1]+1,),dtype=bool)\n nums = np.r_[0:np.shape(conns)[0]]\n self['throat.numbering'] = nums\n self['throat.numbering'] = np.ones((nums[-1]+1,),dtype=bool)\n logger.debug(\"add_boundaries: end of method\")","def update_real_constants(self, diff_bound):\n self.constants.eq_update_constants(diff_bound)\n self.coefficients = self.constants.get_coefficients()\n return","def SetPRBinConstraint(self, model ) :\n tot = np.multiply(self.wish, self.dispo)\n for val in tot :\n if not val : continue\n if self.bound>0 : model += val <= self.valBound\n elif self.bound<0 : model += val >= self.valBound","def reset_boundaries(self):\n self.L = - np.random.uniform(0.0,1.0)\n self.R = self.L + 1.0\n self.Ne = 0.0\n self.Nc = 0.0","def impose_boundary_conditions(self) -> _ImposeBoundaryConditionsResults:\n\n stiffness = self.get_stiffness_matrix()\n force_vector = self.get_force_vector()\n\n restrained_dofs = self.get_supported_dofs()\n\n for axis in range(2):\n stiffness = np.delete(\n stiffness,\n [dof for dof in restrained_dofs],\n axis=axis,\n )\n\n force_vector = np.delete(\n force_vector,\n [dof for dof in restrained_dofs],\n axis=0,\n )\n\n return _ImposeBoundaryConditionsResults(\n stiffness=stiffness,\n force=force_vector,\n )","def __call__(self, u, dx):\n ru = self.central(u)\n for i,b in self.boundaries:\n if __debug__:\n self.log.debug(\n \"Applying boundary: i = \" + repr(i) + \", b = \" + repr(b)\n )\n ru[i] = b(u, apply_at = i)\n return ru/(dx**self.order)","def update_forces(self):\r\n # update all the functions\r\n self.compute_gravity()\r\n self.compute_tides()\r\n self.compute_centrifugal()\r\n self.compute_coriolis()\r\n\r\n # add together the forces into the summation function\r\n self.forcing.assign(self.ftides+self.gravity +\r\n self.centrifugal+self.coriolis)","def boundary(self):\n answer = self.zero()\n for k, v in self.items():\n for idx, cube in enumerate(k):\n acc_dim = sum((cube_l.dimension for cube_l in k[:idx]))\n for i in range(cube.dimension):\n for epsilon in (0, 1):\n new_cube = cube.face(i, epsilon)\n new_k = k[:idx] + (new_cube,) + k[idx + 1:]\n sign_exp = (acc_dim + i + epsilon) % 2\n answer += answer.create({new_k: v * (-1)**sign_exp})\n return answer","def force ( box, strain, r ):\n\n import numpy as np\n from itertools import product\n import math\n \n # It is assumed that positions are in units where box = 1\n # Forces are calculated in units where sigma = 1 and epsilon = 1\n # Lees-Edwards boundaries, in sliding brick arrangement\n # Flow/gradient/vorticity directions are x/y/z == 0/1/2\n # Uses neighbour lists\n\n n = r.shape[0]\n\n # Set up vectors to half the cells in neighbourhood of 3x3x3 cells in cubic lattice\n # The cells are chosen so that if (d0,d1,d2) appears, then (-d0,-d1,-d2) does not.\n # The last three cells are extra ones, to cope with the sheared system\n d = np.array ( [ [ 0, 0, 0], [ 1, 0, 0], [ 1, 0, 1], [-1, 0, 1], [ 0, 0, 1], # 5 cells with d1=0\n [ 1, 1, -1], [ 1, 1, 0], [ 1, 1, 1], # 3 cells with d0= 1, d1=1\n [ 0, 1, -1], [ 0, 1, 0], [ 0, 1, 1], # 3 cells with d0= 0, d1=1\n [-1, 1, -1], [-1, 1, 0], [-1, 1, 1], # 3 cells with d0=-1, d1=1\n [-2, 1, -1], [-2, 1, 0], [-2, 1, 1] ] ) # 3 cells with d0=-2, d1=1\n\n r[:,0] = r[:,0] - np.rint(r[:,1])*strain # Extra correction in box=1 units\n r = r - np.rint(r) # Ensure all atoms in periodic box\n \n sr2_ovr = 1.77 # Overlap threshold (pot > 100)\n r_cut_box = r_cut / box\n r_cut_box_sq = r_cut_box ** 2\n box_sq = box ** 2\n\n # Initialize\n f = np.zeros_like(r)\n total = PotentialType ( pot=0.0, vir=0.0, pyx=0.0, lap=0.0, ovr=False )\n\n # Calculate cell index triplets\n sc = math.floor(box/r_cut) # Number of cells along box edge\n assert sc >= 3, 'System is too small for cells' # Guard against box being too small\n c = np.floor((r+0.5)*sc).astype(np.int_) # N*3 array of cell indices for all atoms\n assert np.all(c>=0) and np.all(c<sc), 'Index error' # Simplistic \"guard\" against roundoff\n\n shift = math.floor(strain*sc) # Strain measured in cell lengths\n\n if fast:\n \n # Build list of arrays, each array holding positions of atoms in a cell\n # At the same time, define a matching set of force arrays in each cell\n # i and j number the atoms in each cell; we do not refer explicitly to indices in r\n rc, fc = [], [] # Initially empty lists of positions and forces\n for ci in product(range(sc),repeat=3): # Triple loop over cells\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\n rc.append(r[mask,:]) # Copy atom coordinates into array, add to list\n fc.append(np.zeros_like(rc[-1])) # Zero corresponding forces, add to list\n\n for ci1, rci in enumerate(rc): # Loop over i-cells, getting all atoms in each i-cell as an array\n ci = np.unravel_index(ci1,(sc,sc,sc)) # Get i-cell triple-indices\n if rci.size==0: # Handle empty cell\n continue\n\n # Set up correct neighbour cell indices\n if ci[1]==sc-1: # i-cell is in the top layer\n dd = d.copy() # Standard list copied, including extra 3 cells\n dd[5:,0] = d[5:,0] - shift # All those looking up need adjustment in the x direction\n else: # i-cell is not in top layer\n dd = d[:-3,:].copy() # Last three extra cells are not needed; shift is not needed\n \n for dj in dd: # Loop over neighbouring j-cells\n cj = ci + dj # Compute neighbour j-cell triple-indices\n cj1 = np.ravel_multi_index(cj,(sc,sc,sc),mode='wrap') # Convert j-cell to single-index\n rcj = rc[cj1] # Get atoms in j-cell as an array\n if rcj.size==0: # Handle empty cell\n continue\n\n rij = rci[:,np.newaxis,:]-rcj[np.newaxis,:,:] # Separation vectors for all i and j\n rij[:,:,0] = rij[:,:,0] - np.rint(rij[:,:,1])*strain # Extra correction in box=1 units\n rij = rij - np.rint(rij) # PBCs in box=1 units\n rij_sq = np.sum(rij**2,axis=2) # Squared separations\n in_range = rij_sq < r_cut_box_sq # Set flags for within cutoff\n\n if ci1==cj1:\n np.fill_diagonal(in_range,False) # Eliminate i==j when i-cell==j-cell\n np.fill_diagonal(rij_sq,1.0) # Avoid divide-by-zero below\n\n rij_sq = rij_sq * box_sq # Now in sigma=1 units\n rij = rij * box # Now in sigma=1 units\n sr2 = np.where ( in_range, 1.0/rij_sq, 0.0 ) # (sigma/rij)**2, only if in range\n ovr = sr2 > sr2_ovr # Overlap if too close\n sr6 = sr2 ** 3\n sr12 = sr6 ** 2\n pot = sr12 - sr6 # LJ potential (cut but not shifted)\n vir = pot + sr12 # LJ virial\n pot = np.where ( in_range, pot+0.25, 0.0 ) # WCA LJ pair potential (cut-and-shifted)\n lap = ( 22.0*sr12 - 5.0*sr6 ) * sr2 # LJ Laplacian\n fij = vir * sr2 # LJ scalar part of forces\n fij = rij * fij[:,:,np.newaxis] # LJ pair forces\n pyx = rij[:,:,1]*fij[:,:,0] # Off-diagonal element of pressure tensor\n\n if ci1==cj1: # Correct for double-counting ij and ji when i-cell==j-cell\n fij = fij / 2\n total = total + PotentialType ( pot=np.sum(pot)/2, vir=np.sum(vir)/2, \n pyx=np.sum(pyx)/2, lap=np.sum(lap)/2, ovr=np.any(ovr) )\n else:\n total = total + PotentialType ( pot=np.sum(pot), vir=np.sum(vir), \n pyx=np.sum(pyx), lap=np.sum(lap), ovr=np.any(ovr) )\n\n fc[ci1][:,:] = fc[ci1][:,:] + np.sum(fij,axis=1) # Aggregate force on atoms in i-cell\n fc[cj1][:,:] = fc[cj1][:,:] - np.sum(fij,axis=0) # Aggregate force on atoms in j-cell\n\n # Copy forces from list of cell arrays to main force array\n for ci in product(range(sc),repeat=3): # Triple loop over cells\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\n ci1 = np.ravel_multi_index(ci,(sc,sc,sc),mode='wrap') # Single-index\n f[mask,:] = fc[ci1] # Copy atom forces from correct cell\n\n else:\n \n # Build list of arrays, each array holding indices of atoms in a cell\n # ki and kj are atom indices in the r array; i and j number the atoms in each cell\n k_array = np.arange(n) # Atom indices 0..N-1\n kc = [] # Initially empty list of indices\n for ci in product(range(sc),repeat=3): # Triple loop over cells\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\n kc.append(k_array[mask]) # Copy atom indices into array, add to list\n\n for ci1, kci in enumerate(kc): # Loop over i-cells, getting atom indices as an array\n ci = np.unravel_index(ci1,(sc,sc,sc)) # Get i-cell triple-indices\n\n # Set up correct neighbour cell indices\n if ci[1]==sc-1: # i-cell is in the top layer\n dd = d # Standard list copied, including extra 3 cells\n dd[5:,0] = dd[5:,0] - shift # All those looking up need adjustment in the x direction\n else:\n dd = d[:-3,:] # Last three extra cells are not needed; shift is not needed\n\n for dj in dd: # Loop over neighbouring j-cells\n cj = ci + dj # Compute neighbour j-cell triple-indices\n cj1 = np.ravel_multi_index(cj,(sc,sc,sc),mode='wrap') # Convert to single-index\n kcj = kc[cj1] # Get indices of atoms in j-cell as an array\n\n for i, ki in enumerate(kci): # Loop over individual atoms in i-cell\n j0 = i+1 if cj1==ci1 else 0 # Only look upwards if i-cell==j-cell\n if j0 >= kcj.size: # Handles (redundantly) empty j-cell and the case \n continue # where j-cell==i-cell and i is last atom\n\n for kj in kcj[j0:]: # Loop over individual atoms in j-cell\n rij = r[ki,:]-r[kj,:] # Separation vector\n rij[0] = rij[0] - np.rint(rij[1])*strain # Extra correction in box=1 units\n rij = rij - np.rint(rij) # Periodic boundary conditions in box=1 units\n rij_sq = np.sum(rij**2) # Squared separation\n\n if rij_sq < r_cut_box_sq: # Check within cutoff\n rij_sq = rij_sq * box_sq # Now in sigma=1 units\n rij = rij * box # Now in sigma=1 units\n sr2 = 1.0 / rij_sq # (sigma/rij)**2\n ovr = sr2 > sr2_ovr # Overlap if too close\n sr6 = sr2 ** 3\n sr12 = sr6 ** 2\n pot = sr12 - sr6 # LJ potential (cut but not shifted)\n vir = pot + sr12 # LJ virial\n pot = pot + 0.25 # WCA LJ potential (cut-and-shifted)\n lap = ( 22.0*sr12 - 5.0*sr6 ) * sr2 # LJ Laplacian\n fij = rij * vir * sr2 # LJ forces\n pyx = rij[1]*fij[0] # Off-diagonal element of pressure tensor\n total = total + PotentialType ( pot=pot, vir=vir, pyx=pyx, lap=lap, ovr=ovr )\n f[ki,:] = f[ki,:] + fij\n f[kj,:] = f[kj,:] - fij\n\n # Multiply results by numerical factors\n f = f * 24.0 # 24*epsilon\n total.pot = total.pot * 4.0 # 4*epsilon\n total.vir = total.vir * 24.0 / 3.0 # 24*epsilon and divide virial by 3\n total.pyx = total.pyx * 24.0 # 24*epsilon\n total.lap = total.lap * 24.0 * 2.0 # 24*epsilon and factor 2 for ij and ji\n \n return total, f","def _redef_via_predef_eqn(self):\r\n time = self.current_T # + self.d_T\r\n\r\n self.Beta = (self.diff_scale * self.thermal_conductivity) / \\\r\n (self.convect_coeff) \r\n self.Epsilon = self.d_T * self.thermal_conductivity / \\\r\n (self.density * self.heat_capacity)\r\n\r\n # Source term.\r\n def F_func(elem, eta):\r\n x = elem.local_to_global(eta)\r\n F = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n F -= self.Epsilon * self.redef_F_laplacian(x[0], x[1], time)\r\n F += self.redef_dTdt(x[0], x[1], time) * self.d_T\r\n return elem.funcs(eta) * F\r\n\r\n self.vF_vect_vol = et.elems_2_array(self.mesh,\r\n F_func,\r\n self.node_map,\r\n gauss_mult=2) # Use double gp_1D\r\n\r\n # Boundary term.\r\n def f_func(elem, eta):\r\n n = elem.guess_normal_vector_global(eta)\r\n f = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n x = elem.local_to_global(eta)\r\n # Evaluate our boundary term.\r\n f += self.Beta * self.redef_f_norm_grad(x[0], x[1], time, n)\r\n f += self.redef_dTdt(x[0], x[1], time) * self.d_T\r\n return elem.funcs(eta) * f\r\n\r\n self.vf_vect_bound = et.edge_2_array(self.mesh,\r\n \"Boundary\",\r\n f_func,\r\n self.node_map,\r\n gauss_mult=2)","def fix_curvature(self) -> None:\n self.n1.fix = True\n self.n2.fix = True","def calculateExteriorElementBoundaryCoefficients(self):\n #\n #get u and grad(u) at the quadrature points\n #\n for ci in range(self.nc):\n self.u[ci].getValuesGlobalExteriorTrace(self.ebqe[('v',ci)],self.ebqe[('u',ci)])\n if self.ebqe.has_key(('grad(u)',ci)):\n self.u[ci].getGradientValuesGlobalExteriorTrace(self.ebqe[('grad(v)',ci)],self.ebqe[('grad(u)',ci)])\n #\n #get coefficients at the element boundary quadrature points\n #\n self.coefficients.evaluate(t = self.timeIntegration.t, c = self.ebqe)\n #\n #time integration, handled directly in ELLAM formulation\n #\n #ignore numerical flux for now\n #if self.numericalFlux != None:\n # self.numericalFlux.calculateExteriorNumericalFlux(self.inflowFlag,self.q,self.ebqe)\n #flux boundary conditions specified through advective flux\n for ci,fbcObject in self.fluxBoundaryConditionsObjectsDict.iteritems():\n for t,g in fbcObject.advectiveFluxBoundaryConditionsDict.iteritems():\n self.ebqe[('advectiveFlux_bc',ci)][t[0],t[1]] = g(self.ebqe[('x')][t[0],t[1]],self.timeIntegration.t)\n self.ebqe[('advectiveFlux_bc_flag',ci)][t[0],t[1]] = 1","def set_basis(self, maps, methods):\n self.eval_method = methods\n\n def get_grad(maps, shape):\n bfref0 = eval_base(maps.qp_coor, diff=True).swapaxes(1, 2)\n if shape == (1,): # scalar variable\n bfref = bfref0\n elif len(shape) == 1: # vector variable\n vec_shape = nm.array(bfref0.shape + shape)\n vec_shape[1] *= shape[0]\n bfref = nm.zeros(vec_shape)\n for ii in nm.arange(shape[0]):\n slc = slice(ii*bfref0.shape[1], (ii+1)*bfref0.shape[1])\n bfref[:, slc, ii] = bfref0\n else: # higher-order tensors variable\n msg = \"Evaluation of basis has not been implemented \\\n for higher-order tensors yet.\"\n raise NotImplementedError(msg)\n return bfref\n\n def get_val(maps, shape):\n bfref0 = eval_base(maps.qp_coor, diff=False).swapaxes(1, 2)\n\n if self.shape == (1,): # scalar variable\n bfref = bfref0\n elif len(shape) == 1:\n vec_shape = nm.array(bfref0.shape)\n vec_shape[1:3] *= shape[0]\n bfref = nm.zeros(vec_shape)\n for ii in nm.arange(shape[0]):\n slc = slice(ii*bfref0.shape[1], (ii+1)*bfref0.shape[1])\n bfref[:, slc] = bfref0\n else: # higher-order tensors variable\n msg = \"Evaluation of basis has not been implemented \\\n for higher-order tensors yet.\"\n raise NotImplementedError(msg)\n return bfref\n\n eval_base = self.interp.poly_spaces['v'].eval_base\n if self.eval_method[0] == 'val':\n bfref = get_val(maps, self.shape)\n\n elif self.eval_method[0] == 'grad':\n bfref = get_grad(maps, self.shape)\n\n elif self.eval_method[0] == 'div':\n bfref = get_grad(maps, self.shape)\n\n else:\n raise NotImplementedError(\"The method '%s' is not implemented\" \\\n % (self.eval_method))\n\n self.bfref = bfref\n self.n_basis = self.bfref.shape[1]","def set_rhs(self):\n k = self.istore[:, 0]\n ksym = self.stencil.get_symmetric()[k]\n self.rhs[:] = self.feq[k, np.arange(k.size)] + self.feq[ksym, np.arange(k.size)]","def set_rhs(self):\n k = self.istore[:, 0]\n ksym = self.stencil.get_symmetric()[k]\n self.rhs[:] = self.feq[k, np.arange(k.size)] + self.feq[ksym, np.arange(k.size)]","def update_forces(self):\n\n pass","def updateForces(self):\n for atom1 in range(0, self.numAtoms-1):\n for atom2 in range(atom1+1, self.numAtoms):\n self.calculateForce(atom1, atom2)\n \n # Multiply by constants \n for atom in range(0, self.numAtoms):\n self.atoms[atom].fx *= 48*self.e\n self.atoms[atom].fy *= 48*self.e\n self.atoms[atom].fz *= 48*self.e\n self.atoms[atom].potential *= 4*self.e","def term_1(\n omega1, # vorticity-1\n omega2, # vorticity-2\n omega3, # vorticity-3\n enst, # enstrophy\n nu_sgs, # turbulent viscosity\n h = True): # spatial step size\n #---------------------------------------------------------------------#\n # Setting default values #\n #---------------------------------------------------------------------#\n if h is True:\n h = 2.0*np.pi/64.0\n #---------------------------------------------------------------------#\n # Preallocating space #\n #---------------------------------------------------------------------#\n term = np.zeros((64,64,64))\n #---------------------------------------------------------------------#\n # Enstrophy term #\n #---------------------------------------------------------------------#\n term += np.gradient(\\\n np.gradient(enst, h, edge_order=2)[2], h, edge_order=2)[2]\n term += np.gradient(\\\n np.gradient(enst, h, edge_order=2)[1], h, edge_order=2)[1]\n term += np.gradient(\\\n np.gradient(enst, h, edge_order=2)[0], h, edge_order=2)[0]\n #---------------------------------------------------------------------#\n # Dissipation #\n #---------------------------------------------------------------------#\n omega1_grad = np.gradient(omega1, h, edge_order=2)\n omega2_grad = np.gradient(omega2, h, edge_order=2)\n omega3_grad = np.gradient(omega3, h, edge_order=2)\n term -= np.square(omega1_grad[2])\n term -= np.square(omega1_grad[1])\n term -= np.square(omega1_grad[0])\n term -= np.square(omega2_grad[2])\n term -= np.square(omega2_grad[1])\n term -= np.square(omega2_grad[0])\n term -= np.square(omega3_grad[2])\n term -= np.square(omega3_grad[1])\n term -= np.square(omega3_grad[0])\n #---------------------------------------------------------------------#\n # Applying the subgrid stress #\n #---------------------------------------------------------------------#\n term *= nu_sgs\n\n return term","def compute_bounds(self, weights, add_coeff, dual_vars, lower_bounds, upper_bounds, store_primal=False):\n x0_coeff = -weights[0].backward(dual_vars.mus[0])\n x0 = torch.where(x0_coeff >= 0, lower_bounds[0].unsqueeze(1), upper_bounds[0].unsqueeze(1))\n bound = utils.bdot(x0, x0_coeff)\n if store_primal:\n self.bounds_primal = x0\n else:\n del x0\n del x0_coeff\n\n for lay_idx in range(1, len(weights)):\n lbs = lower_bounds[lay_idx].unsqueeze(1).clamp(None, 0)\n ubs = upper_bounds[lay_idx].unsqueeze(1).clamp(0, None)\n neg_bias = ((lbs * ubs) / (ubs - lbs))\n neg_bias.masked_fill_(ubs == lbs, 0) # cover case in which ubs & lbs coincide\n bound += utils.bdot(dual_vars.lambdas[lay_idx - 1].clamp(0, None), neg_bias)\n bound -= utils.bdot(dual_vars.mus[lay_idx - 1], weights[lay_idx - 1].get_bias())\n\n bound += utils.bdot(add_coeff, weights[-1].get_bias())\n return bound","def setup_observation_term(background_data_dict,\n obs_type_vector, obs_data_vector, obs_lat_vector, obs_lon_vector,\n background_type_vector, background_data_vector, background_lat_vector, background_lon_vector,\n direct_obs_operator,\n analysis_increment_vector_symbol,\n increment_data=0.001):\n linearized_obs_operator = sympy.Matrix(\n numpy.ones((len(obs_type_vector), len(background_type_vector))))\n background_derived_obs = sympy.Matrix(\n numpy.ones((len(obs_type_vector), 1)))\n\n for i_obs in range(0, len(obs_data_vector)):\n cur_obs_type = str(obs_type_vector[i_obs])\n cur_obs_lat = float(obs_lat_vector[i_obs])\n cur_obs_lon = float(obs_lon_vector[i_obs])\n\n cur_bk_derived_obs_operator = direct_obs_operator[cur_obs_type]\n required_bk_vars = cur_bk_derived_obs_operator.free_symbols\n \n # 1. calculate h(x):\n bkg_shape = background_data_dict['lat'].shape\n bkg_weight_0 = 0\n bkg_weight_1 = 0\n for ii in range(0, bkg_shape[0]):\n for jj in range(0, bkg_shape[1]):\n cur_bk_lat = background_data_dict['lat'][ii, jj]\n cur_bk_lon = background_data_dict['lon'][ii, jj]\n\n cur_obs_operator_input = {}\n for required_bk_var in required_bk_vars:\n cur_obs_operator_input[str(required_bk_var)] = background_data_dict[str(required_bk_var)][ii, jj]\n\n cur_distance = math.sqrt((cur_obs_lat - cur_bk_lat)**2 + (cur_obs_lon - cur_bk_lon)**2)\n cur_distance_weight_0 = (direct_obs_operator[cur_obs_type].subs(cur_obs_operator_input))/float(cur_distance**2)\n cur_distance_weight_1 = 1.0/float(cur_distance**2)\n bkg_weight_0 = bkg_weight_0 + cur_distance_weight_0\n bkg_weight_1 = bkg_weight_1 + cur_distance_weight_1\n \n background_derived_obs[i_obs, 0] = bkg_weight_0/bkg_weight_1\n final_bkg_weight_1 = bkg_weight_1\n \n # 2. find linearized observation operator\n # n = 0\n for i_bkg in range(0, len(background_type_vector)):\n cur_bk_lat = float(background_lat_vector[i_bkg])\n cur_bk_lon = float(background_lon_vector[i_bkg])\n cur_bk_type = str(background_type_vector[i_bkg])\n \n cur_distance = math.sqrt((cur_obs_lat - cur_bk_lat)**2 + (cur_obs_lon - cur_bk_lon)**2)\n cur_distance_weight_0 = cur_distance ** 2\n distance_term = 1.0/(cur_distance_weight_0 * final_bkg_weight_1)\n \n l = sympy.diff(direct_obs_operator[cur_obs_type], cur_bk_type)\n linearized_obs_operator[i_obs, i_bkg] = distance_term*l.subs(\n {cur_bk_type: float(background_data_vector[i_bkg])})\n \n linearized_obs_operator_with_increments = \\\n linearized_obs_operator*analysis_increment_vector_symbol\n \n # get the innovation:\n innovation = obs_data_vector - background_derived_obs - \\\n linearized_obs_operator_with_increments\n return linearized_obs_operator, innovation, background_derived_obs","def build_constraints_boundaries(self):\n\n # Trapezoidal and Hermite-Simpson methods can't compute\n # defects at the last node contrary to pseudospectral methods\n coll_method = self.options['tr_method'] in [\n 'trapezoidal', 'hermite-simpson']\n n_nodes = self.problem.prm['n_nodes'] - \\\n 1 if coll_method else self.problem.prm['n_nodes']\n\n # Defects lower and upper boundaries\n defects_low = np.zeros(\n self.problem.prm['n_states'] * n_nodes)\n defects_upp = np.zeros(\n self.problem.prm['n_states'] * n_nodes)\n\n # Path lower and upper boundaries\n path_low = np.hstack([self.problem.low_bnd.path]\n * (self.problem.prm['n_nodes']))\n path_upp = np.hstack([self.problem.upp_bnd.path]\n * (self.problem.prm['n_nodes']))\n\n # Events lower and upper boundaries\n event_low = self.problem.low_bnd.event\n event_upp = self.problem.upp_bnd.event\n\n # Assembly of the lower and upper boundaries vectors\n low = np.concatenate((defects_low, path_low, event_low))\n upp = np.concatenate((defects_upp, path_upp, event_upp))\n\n return low, upp","def boundary_conditions(self):\n pass","def relax(self):\n # print(\"putin\", self.level.rhs.reshape(-1)[:])\n # print(\"getout\", self.solver(self.level.rhs.reshape(-1)))\n\n self.level.mid[:] = self.solver(self.level.rhs.reshape(-1)).reshape(self.level.mid.shape)","def update_forces(self):\n element: Cell\n element1: Cell\n element2: Cell\n for element in self.cells:\n element.force = Vector(.0, .0, .0)\n\n tmp_systems = self.cells.copy()\n to_delete = set()\n for element1 in self.cells:\n for element2 in self.cells:\n if element1 == element2:\n continue\n if element2.distance(element1) <= element2.r_max:\n force = find_force(element1, element2)\n element1.force += force\n element2.force += -force\n to_delete.add(element2)\n tmp_systems -= to_delete\n to_delete.clear()","def applyForce(self, F, dT):","def add_cp_le_RBM_terms_alt(K, cons_pot_mesh, lin_geo_mesh):\n num_faces = cons_pot_mesh.get_faces().shape[0]\n x_c = lin_geo_mesh.get_centroid()\n w = lin_geo_mesh.get_w()\n A_m = lin_geo_mesh.get_A_m()\n S_D = lin_geo_mesh.get_surface_area()\n\n for face_num in range(num_faces):\n face_nodes = lin_geo_mesh.get_tri_nodes(face_num)\n face_hs = lin_geo_mesh.get_hs(face_num)\n face_center = lin_geo_mesh.get_tri_center(face_num)\n v_sub_mat = (1. / S_D) * (np.identity(3) * 0.5 * face_hs) # simple integral\n tmp_omega = []\n for m in range(3):\n def make_omega_quad(w, A_m):\n def omega_quad(xi, eta, nodes):\n pos = geo.linear_interp(xi, eta, nodes)\n X = pos - x_c\n return np.cross(w, X)\n return omega_quad\n tmp_omega.append(gq.int_over_tri_lin(\n make_omega_quad(w[m], A_m[m]),\n face_nodes,\n face_hs,\n ))\n for src_num in range(num_faces):\n K[(3 * src_num):(3 * src_num + 3),\n (3 * face_num):(3 * face_num + 3)] += v_sub_mat\n src_center = cons_pot_mesh.get_node(src_num)\n X_0 = src_center - x_c\n tmp_arr = []\n for m in range(3):\n tmp_arr.append(np.outer((1./ A_m[m]) * np.cross(w[m], X_0), tmp_omega[m]))\n tmp_arr = np.array(tmp_arr)\n omega_mat = np.sum(tmp_arr, axis=0)\n K[(3 * src_num):(3 * src_num + 3),\n (3 * face_num):(3 * face_num + 3)] += omega_mat","def do_relax(self):\n raise NotImplementedError","def regularize_if_necessary(self) -> None:\n # As described in [wang2014], all entities and relations are used to compute the regularization term\n # which enforces the defined soft constraints.\n super().regularize_if_necessary(\n self.entity_embeddings.weight,\n self.normal_vector_embeddings.weight,\n self.relation_embeddings.weight,\n )","def test_update_boundary_opt(self):\n self.set_up()\n boundary_opt_new = np.hstack((self.vmecOptimization.boundary_opt,\n self.vmecOptimization.boundary_opt))\n self.assertRaises(ValueError,self.vmecOptimization.update_boundary_opt,\n boundary_opt_new)\n boundary_opt_new = np.copy(self.vmecOptimization.boundary_opt)\n boundary_opt_new[0] = 1\n self.vmecOptimization.update_boundary_opt(boundary_opt_new)\n self.assertEqual(1,self.vmecOptimization.boundary_opt[0])\n self.tear_down()","def calculate_thickness_terms(self):\n\n self.calculate_min_thickness()\n self._calculate_driven_mass()\n self._calculate_resonant_frequency()\n self._calculate_quilting_error()","def incumbent(self):\n return self.boundary_handler.repair(self.mean)","def _set_bounds(b, x, n):\n for j in range(1, n - 1):\n for i in range(1, n - 1):\n x[index_of(i, j, 0, n)] = -x[index_of(i, j, 1, n)] if b == 3 else x[index_of(i, j, 1, n)]\n x[index_of(i, j, 0, n - 1)] = -x[index_of(i, j, 1, n - 2)] if b == 3 else x[index_of(i, j, 1, n - 2)]\n for k in range(1, n - 1):\n for i in range(1, n - 1):\n x[index_of(i, 0, k, n)] = -x[index_of(i, 1, k, n)] if b == 2 else x[index_of(i, 1, k, n)]\n x[index_of(i, n - 1, 0, n - 1)] = -x[index_of(i, n - 2, k, n - 2)] if b == 2 else x[\n index_of(i, n - 2, k, n - 2)]\n for k in range(1, n - 1):\n for j in range(1, n - 1):\n x[index_of(0, j, k, n)] = -x[index_of(1, j, k, n)] if b == 1 else x[index_of(1, j, k, n)]\n x[index_of(n - 1, j, k, n - 1)] = -x[index_of(n - 2, j, k, n)] if b == 1 else x[\n index_of(n - 2, j, k, n)]\n\n x[index_of(0, 0, 0, n)] = 1 / 3 * (x[index_of(1, 0, 0, n)] + x[index_of(0, 1, 0, n)] + x[index_of(0, 0, 1, n)])\n x[index_of(0, n - 1, 0, n)] = 1 / 3 * (\n x[index_of(1, n - 1, 0, n)] + x[index_of(0, n - 2, 0, n)] + x[index_of(0, n - 1, 1, n)])\n x[index_of(0, 0, n - 1, n)] = 1 / 3 * (\n x[index_of(1, 0, n - 1, n)] + x[index_of(0, 1, n - 1, n)] + x[index_of(0, 0, n - 2, n)])\n x[index_of(0, n - 1, n - 1, n)] = 1 / 3 * (\n x[index_of(1, n - 1, n - 1, n)] + x[index_of(0, n - 2, n - 1, n)] + x[index_of(0, n - 1, n - 2, n)])\n x[index_of(n - 1, 0, 0, n)] = 1 / 3 * (\n x[index_of(n - 2, 0, 0, n)] + x[index_of(n - 1, 1, 0, n)] + x[index_of(n - 1, 0, 1, n)])\n x[index_of(n - 1, n - 1, 0, n)] = 1 / 3 * (\n x[index_of(n - 2, n - 1, 0, n)] + x[index_of(n - 1, n - 2, 0, n)] + x[index_of(n - 1, n - 1, 1, n)])\n x[index_of(n - 1, 0, n - 1, n)] = 1 / 3 * (\n x[index_of(n - 2, 0, n - 1, n)] + x[index_of(n - 1, 1, n - 1, n)] + x[index_of(n - 1, 0, n - 2, n)])\n x[index_of(n - 1, n - 1, n - 1, n)] = 1 / 3 * (\n x[index_of(n - 2, n - 1, n - 1, n)] + x[index_of(n - 1, n - 2, n - 1, n)] + x[\n index_of(n - 1, n - 1, n - 2, n)])","def set_initial_condition(self):\n X0 = np.array([0.5, 0.5])\n XB = self.bary\n q0 = 1 + np.exp(-0.5*(np.sum((XB-X0[np.newaxis])**2., axis=1))/0.1**2)\n q1 = np.zeros(q0.shape)\n #import pdb; pdb.set_trace()\n return np.array([q0, q1, q1]).T","def set_boundary(self, t):\n gw_level = self.gwhead[t]\n if np.isfinite(gw_level):\n self.gw.potential = gw_level","def __get_new_restriction_branch_and_bound(self, tableau, var_col, b_value):\n restriction_row = np.zeros((tableau.get_tableau_num_cols())).astype('object')\n restriction_row[var_col] = 1\n restriction_row[tableau.get_tableau_num_cols() - 1] = b_value\n\n for i in xrange(0, len(restriction_row)):\n restriction_row[i] = Fraction(restriction_row[i])\n\n return restriction_row","def compute_ghost_series(self,terms):\n\t\tp=self.p\n\t\tcomp=self.comp\n\t\tf1=self.f1\n\t\tf2=self.f2\n\n\t\tghost_coefs = [[] for i in range(terms+1)]\n\n\n\t\tk=comp;\n\t\tif k==0 or k==1:\n\t\t\tk=k+p-1\n\n\t\t## Precompute the needed dimensions\n\t\tself.f1v = [f1(k)]\n\t\tself.f2v = [f2(k)]\n\t\tk = k + p-1\n\t\twhile self.f1v[len(self.f1v)-1] <= terms+1:\n\t\t\tself.f1v += [f1(k)]\n\t\t\tself.f2v += [f2(k)]\n\t\t\tk = k + p-1\n\t\t\n\t\t## Starting at weight 2, we run through weights in the component,\n\t\t## compute the associated indices, and then record the weights at those\n\t\t## indices with appropriate multiplicities\n\n\t\tk = comp;\n\t\tif k==0 or k==1:\n\t\t\tk=k+p-1\n\t\tn = 0\n\n\t\tinds = range(self.f1v[n]+1,self.f1v[n]+self.f2v[n])\n\t\twhile (len(inds)==0 or inds[0]<=terms+1):\n\t\t\t## This loops adds the weights to the appropriate indices with the appropriate multiplicities\n\t\t\tfor m in range(floor((len(inds)+1)/2)):\n\t\t\t\tif m < floor(len(inds)/2):\n\t\t\t\t\tif inds[m]<=terms:\n\t\t\t\t\t\tghost_coefs[inds[m]] += [(k,m+1)]\n\t\t\t\t\tif (inds[len(inds)-1-m]<=terms):\n\t\t\t\t\t\tghost_coefs[inds[len(inds)-1-m]] += [(k,m+1)]\n\t\t\t\telse:\n\t\t\t\t\tif inds[m]<=terms:\n\t\t\t\t\t\tghost_coefs[inds[m]] += [(k,m+1)]\n\t\t\tk = k + p-1\n\t\t\tn = n + 1\n\t\t\tinds = range(self.f1v[n]+1,self.f1v[n]+self.f2v[n])\n\t\tself.series=ghost_coefs","def normalize_all(self):\n #for i, vector in enumerate(self.real_vectors):\n # self.real_vectors[i] /= np.linalg.norm(vector)\n self.vectors /= np.linalg.norm(self.vectors, axis=1).reshape(-1,1)\n for i, vector in enumerate(self.real_vectors):\n vector.set(self.vectors[i])","def additional_equations(self, k):\n ######################################################################\n # equation for saturated liquid at hot side outlet\n if self.subcooling.val is False:\n o1 = self.outl[0].to_flow()\n self.residual[k] = o1[2] - h_mix_pQ(o1, 0)\n k += 1","def SetPRBinCatConstraint( self, model ) :\n tot = np.dot( self.wish.T, self.dispo )\n for val in tot :\n if not val : continue\n if self.bound>0 : model += val <= self.valBound\n elif self.bound<0 : model += val >= self.valBound","def update(self):\n self._g, self._B = self._constraint_assembler.preallocate_g_and_B(self._no_of_dofs_unconstrained,\n self._dofidxs(),\n self._no_of_constraints_by_object())","def set_freq_relaxation(self):\n self.num_omega=5\n self.omega=np.zeros(self.num_omega)\n iOmH = 3 ; # indexing for the frequencies.\n iOmX = 1 ; #\n # First determine the frequencies omega and J from given inputs.\n self.omega[iOmH] = -1.0*self.gH.gamma*self.B_0*self.time_fact\n self.omega[iOmX] = -1.0*self.gX.gamma*self.B_0*self.time_fact\n self.omega[iOmH-iOmX] = (self.omega[iOmH]-self.omega[iOmX])\n self.omega[iOmH+iOmX] = (self.omega[iOmH]+self.omega[iOmX])","def _merge_boundaries(self):\n optical = self._amalgamated_optical\n if bool(optical):\n optical[\"catagory\"] = OPTICAL * tf.ones_like(\n optical[\"xp\"],\n dtype=tf.int64\n )\n self._optical_count = tf.shape(\n optical[\"xp\"],\n out_type=tf.int64\n )[0]\n else:\n self._optical_count = 0\n \n stop = self._amalgamated_stop\n if bool(stop):\n stop[\"catagory\"] = STOP * tf.ones_like(\n stop[\"xp\"],\n dtype=tf.int64\n )\n self._stop_count = tf.shape(\n stop[\"xp\"],\n out_type=tf.int64\n )[0]\n else:\n self._stop_count = 0\n \n target = self._amalgamated_target\n if bool(target):\n target[\"catagory\"] = TARGET * tf.ones_like(\n target[\"xp\"],\n dtype=tf.int64\n )\n self._target_count = tf.shape(\n target[\"xp\"],\n out_type=tf.int64\n )[0]\n else:\n self._target_count = 0\n \n self._merged = amalgamate(\n [optical, stop, target], \n TRIANGLE_GEO_SIG | {\"catagory\"}\n )","def boundary(self):\n\n answer = self.zero()\n if self.torsion == 2:\n for k in self.keys():\n for idx in range(0, len(k)):\n bdry_summand = k[:idx] + k[idx + 1:]\n if k[idx] in bdry_summand:\n answer += self.create({bdry_summand: 1})\n return answer\n if self.convention == 'Berger-Fresse':\n for k, v in self.items():\n # determining the signs of the summands\n signs = {}\n alternating_sign = 1\n for idx, i in enumerate(k):\n if i in k[idx + 1:]:\n signs[idx] = alternating_sign\n alternating_sign *= (-1)\n elif i in k[:idx]:\n occurs = (pos for pos, j in enumerate(k[:idx]) if i == j)\n signs[idx] = signs[max(occurs)] * (-1)\n else:\n signs[idx] = 0\n # computing the summands\n for idx in range(0, len(k)):\n bdry_summand = k[:idx] + k[idx + 1:]\n if k[idx] in bdry_summand:\n answer += self.create({bdry_summand: signs[idx] * v})\n if self.convention == 'McClure-Smith':\n for k, v in self.items():\n sign = 1\n for i in range(1, max(k) + 1):\n for idx in (idx for idx, j in enumerate(k) if j == i):\n new_k = k[:idx] + k[idx + 1:]\n if k[idx] in new_k:\n answer += answer.create({new_k: v * sign})\n sign *= -1\n sign *= -1\n return answer","def equalize(pair, bias_axis, word_to_vec_map):\n\n ### START CODE HERE ###\n # Step 1: Select word vector representation of \"word\". Use word_to_vec_map. (≈ 2 lines)\n w1, w2 = pair\n e_w1, e_w2 = (word_to_vec_map[w1], word_to_vec_map[w2])\n\n # Step 2: Compute the mean of e_w1 and e_w2 (≈ 1 line)\n mu = (e_w1 + e_w2) / 2\n\n # Step 3: Compute the projections of mu over the bias axis and the orthogonal axis (≈ 2 lines)\n mu_B = np.dot(mu, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\n mu_orth = mu - mu_B\n\n # Step 4: Use equations (7) and (8) to compute e_w1B and e_w2B (≈2 lines)\n e_w1B = np.dot(e_w1, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\n e_w2B = np.dot(e_w2, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\n\n # Step 5: Adjust the Bias part of e_w1B and e_w2B using the formulas (9) and (10) given above (≈2 lines)\n corrected_e_w1B = np.sqrt(np.abs(1 - np.sum(np.dot(mu_orth, mu_orth)))) * (e_w1B - mu_B) / np.sqrt(\n np.sum(np.dot(e_w1 - mu_orth - mu_B, e_w1 - mu_orth - mu_B)))\n corrected_e_w2B = np.sqrt(np.abs(1 - np.sum(np.dot(mu_orth, mu_orth)))) * (e_w2B - mu_B) / np.sqrt(\n np.sum(np.dot(e_w2 - mu_orth - mu_B, e_w2 - mu_orth - mu_B)))\n\n # Step 6: Debias by equalizing e1 and e2 to the sum of their corrected projections (≈2 lines)\n e1 = corrected_e_w1B + mu_orth\n e2 = corrected_e_w2B + mu_orth\n\n ### END CODE HERE ###\n\n return e1, e2","def calculateRightHandSide(self):\n\n #each element triangulation.simplices is a list with the point indices of the triangle\n for ele,triPoints in enumerate(self.triangulation.simplices):\n elementRHS = self.calculateElementRightHandSide(ele)\n\n for index,entry in enumerate(elementRHS):\n self.rightHandSide[triPoints[index]] += entry\n\n #overwrite the values at the prescribed boundaries condition\n for indexValue in self.prescribedValues:\n self.rightHandSide[int(indexValue[0])] = indexValue[1]\n #print(self.rightHandSide)","def add_cp_le_RBM_terms(K, cons_pot_mesh, lin_geo_mesh):\n num_faces = cons_pot_mesh.get_faces().shape[0]\n x_c = lin_geo_mesh.get_centroid()\n w = lin_geo_mesh.get_w()\n A_m = lin_geo_mesh.get_A_m()\n S_D = lin_geo_mesh.get_surface_area()\n\n for face_num in range(num_faces):\n face_nodes = lin_geo_mesh.get_tri_nodes(face_num)\n face_hs = lin_geo_mesh.get_hs(face_num)\n v_sub_mat = (1. / S_D) * (np.identity(3) * 0.5 * face_hs) # simple integral\n def omega_quad(xi, eta, nodes):\n pos = geo.linear_interp(xi, eta, nodes)\n X = pos - x_c\n return np.einsum(\"lrs,s->lr\", geo.LC_3, X)\n tmp_omega = gq.int_over_tri_lin(\n omega_quad,\n face_nodes,\n face_hs,\n )\n tmp_arr = []\n for m in range(3):\n tmp_arr.append((1./ A_m[m]) * np.outer(w[m], np.einsum(\"l,ls\", w[m], tmp_omega)))\n tmp_arr = np.array(tmp_arr)\n tmp_omega_mat = np.sum(tmp_arr, axis=0)\n for src_num in range(num_faces):\n K[(3 * src_num):(3 * src_num + 3),\n (3 * face_num):(3 * face_num + 3)] += v_sub_mat\n #src_center = cons_pot_mesh.get_node(src_num)\n src_center = lin_geo_mesh.get_tri_center(src_num)\n X_0 = src_center - x_c\n omega_mat = np.einsum(\"ijk,js,k->is\", geo.LC_3, tmp_omega_mat, X_0)\n K[(3 * src_num):(3 * src_num + 3),\n (3 * face_num):(3 * face_num + 3)] += omega_mat","def set_bc(self, problem):\n bcs = problem.bcs\n n_bound = cfg.const['N_GHOST_CELLS']\n # Left X-b.c.\n for i in range(0, self.i_min):\n for j in range(self.j_min, self.j_max):\n for k in range(self.k_min, self.k_max): \n if bcs[0] == 't': \n self.U[i][j][k] = self.U[self.i_min][j][k]\n elif bcs[0] == 'w':\n for num in [0, 2, 3, 4]: # 0 -> 3, 1 -> 2, i_min-1 -> i_min, i_min-2 -> i_min+1\n self.U[i][j][k][num] = self.U[self.i_min + (self.i_min - i - 1)][j][k][num]\n for num in [1]:\n self.U[i][j][k][num] = - self.U[self.i_min + (self.i_min - i - 1)][j][k][num]\n else:\n print(\"Errof field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")\n # Right X-b.c.\n for i in range(self.i_max, self.i_max+n_bound):\n for j in range(self.j_min, self.j_max):\n for k in range(self.k_min, self.k_max): \n if bcs[1] == 't':\n self.U[i][j][k] = self.U[self.i_max-1][j][k]\n elif bcs[1] == 'w':\n for num in [0, 2, 3, 4]: # i_max -> i_max-1 , i_max+1-> i_max-2\n self.U[i][j][k][num] = self.U[self.i_max - (i - self.i_max + 1)][j][k][num]\n for num in [1]:\n self.U[i][j][k][num] = - self.U[self.i_max - (i - self.i_max + 1)][j][k][num]\n else:\n print(\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")\n # Left Y-b.c.\n for i in range(0, self.i_max+n_bound):\n for j in range(0, self.j_min):\n for k in range(self.k_min, self.k_max): \n if bcs[2] == 't':\n self.U[i][j][k] = self.U[i][self.j_min][k]\n elif bcs[2] == 'w':\n for num in [0, 1, 3, 4]:\n self.U[i][j][k][num] = self.U[i][self.j_min + (self.j_min - j - 1)][k][num]\n for num in [2]:\n self.U[i][j][k][num] = - self.U[i][self.j_min + (self.j_min - j - 1)][k][num]\n else:\n print(\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")\n # Right Y-b.c.\n for i in range(0, self.i_max+n_bound):\n for j in range(self.j_max, self.j_max+n_bound):\n for k in range(self.k_min, self.k_max): \n if bcs[3] == 't':\n self.U[i][j][k] = self.U[i][self.j_max-1][k]\n elif bcs[3] == 'w':\n for num in [0, 1, 3, 4]:\n self.U[i][j][k][num] = self.U[i][self.j_max - (j - self.j_max + 1)][k][num]\n for num in [2]:\n self.U[i][j][k][num] = -self.U[i][self.j_max - (j - self.j_max + 1)][k][num]\n else:\n print(\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")\n # Left Z-b.c.\n for i in range(0, self.i_max+n_bound):\n for j in range(0, self.j_max+n_bound):\n for k in range(0, self.k_min): \n if bcs[4] == 't':\n self.U[i][j][k] = self.U[i][j][self.k_min]\n elif bcs[4] == 'w':\n for num in [0, 1, 2, 4]:\n self.U[i][j][k][num] = self.U[i][j][self.k_min + (self.k_min - k - 1)][num]\n for num in [3]:\n self.U[i][j][k][num] = - self.U[i][j][self.k_min + (self.k_min - k - 1)][num]\n else:\n print(\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")\n # Right Z-b.c.\n for i in range(0, self.i_max+n_bound):\n for j in range(0, self.j_max+n_bound):\n for k in range(self.k_max, self.k_max+n_bound):\n if bcs[5] == 't':\n self.U[i][j][k] = self.U[i][j][self.k_max-1]\n elif bcs[5] == 'w':\n for num in [0, 1, 2, 4]:\n self.U[i][j][k][num] = self.U[i][j][self.k_max - (k - self.k_max + 1)][num]\n for num in [3]:\n self.U[i][j][k][num] = - self.U[i][j][self.k_max - (k - self.k_max + 1)][num]\n else:\n print(\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")","def ComputeBasis(self, p_float=..., p_float=..., p_float=..., *args, **kwargs):\n ...","def set_bounds_atom(self,bounds):\n assert bounds.shape == (2,self.Phi.d)\n self.bounds = bounds # data bounds\n self.bounds_atom = bounds.T.tolist()\n for i in range(self.Phi.d): # bounds for the variance in each dimension\n max_variance_this_dimension = (bounds[1][i]-bounds[0][i])**2\n self.bounds_atom.append([self.variance_relative_lowerbound*max_variance_this_dimension,\n self.variance_relative_upperbound*max_variance_this_dimension])","def real_reduce(self, bound, large_constant):\n approximation_matrix = self.generate_approximation_matrix(large_constant)\n LLL_matrix = self.generate_LLL_matrix(approximation_matrix)\n GS_matrix = self.generate_GS_matrix(LLL_matrix) \n minimal_vector_bound = self.calculate_minimal_vector_bound(large_constant, LLL_matrix, GS_matrix)\n S, T = self.calculate_S_and_T(self.coefficients[\"Z_bounds\"])\n print('ST',T**2 + S)\n new_bound = self.real_reduce_new_bound(large_constant, minimal_vector_bound, S, T)\n print('diff_bound',new_bound)\n return new_bound","def additional_equations(self, k):\n ######################################################################\n # equation for saturated gas at hot side outlet\n o1 = self.outl[0].to_flow()\n self.residual[k] = o1[2] - h_mix_pQ(o1, 1)","def test_handling_of_variable_bound_sums_in_merge(free_alg):\n\n dr = free_alg\n p = dr.names\n\n x = IndexedBase('x')\n v = p.v\n i = p.i\n r = p.R\n\n first = dr.sum((i, r), x[i] * v[i])\n\n # First trial, when the ranges are really the same.\n assert dr.simplify(\n first - dr.sum((i, r), x[i] * v[i])\n ) == 0\n\n # This time, they should not be merged.\n assert dr.simplify(\n first - dr.sum((i, r[0, Symbol('n')]), x[i] * v[i])\n ).n_terms == 2","def compute_bound(self, sstats, totals):\n w = self.vocab_len\n t = self.num_time_slices\n\n term_1 = 0\n term_2 = 0\n term_3 = 0\n\n val = 0\n ent = 0\n\n chain_variance = self.chain_variance\n # computing mean, fwd_mean\n self.mean, self.fwd_mean = \\\n (np.array(x) for x in zip(*(self.compute_post_mean(w, self.chain_variance) for w in range(w))))\n self.zeta = self.update_zeta()\n\n val = sum(self.variance[w][0] - self.variance[w][t] for w in range(w)) / 2 * chain_variance\n\n logger.info(\"Computing bound, all times\")\n\n for t in range(1, t + 1):\n term_1 = 0.0\n term_2 = 0.0\n ent = 0.0\n for w in range(w):\n\n m = self.mean[w][t]\n prev_m = self.mean[w][t - 1]\n\n v = self.variance[w][t]\n\n # w_phi_l is only used in Document Influence Model; the values are always zero in this case\n # w_phi_l = sslm.w_phi_l[w][t - 1]\n # exp_i = np.exp(-prev_m)\n # term_1 += (np.power(m - prev_m - (w_phi_l * exp_i), 2) / (2 * chain_variance)) -\n # (v / chain_variance) - np.log(chain_variance)\n\n term_1 += \\\n (np.power(m - prev_m, 2) / (2 * chain_variance)) - (v / chain_variance) - np.log(chain_variance)\n term_2 += sstats[w][t - 1] * m\n ent += np.log(v) / 2 # note the 2pi's cancel with term1 (see doc)\n\n term_3 = -totals[t - 1] * np.log(self.zeta[t - 1])\n val += term_2 + term_3 + ent - term_1\n\n return val","def _construct_compute_fe_terms(self):\n # setup some symbolic variables for theano to deal with\n xi = T.matrix()\n xo = T.matrix()\n _, hi_zmuv = self._construct_zmuv_samples(xi, 1)\n # construct values to output\n nll = self.nlli[-1]\n kld = self.kld_z.flatten() + self.kld_hi_q2p.flatten()\n # compile theano function for a one-sample free-energy estimate\n fe_term_sample = theano.function(inputs=[ xi, xo ], \\\n outputs=[nll, kld], \\\n givens={self.x_in: xi, \\\n self.x_out: xo, \\\n self.hi_zmuv: hi_zmuv}, \\\n updates=self.scan_updates)\n # construct a wrapper function for multi-sample free-energy estimate\n def fe_term_estimator(XI, XO, sample_count):\n # compute a multi-sample estimate of variational free-energy\n nll_sum = np.zeros((XI.shape[0],))\n kld_sum = np.zeros((XI.shape[0],))\n for i in range(sample_count):\n result = fe_term_sample(XI, XO)\n nll_sum += result[0].ravel()\n kld_sum += result[1].ravel()\n mean_nll = nll_sum / float(sample_count)\n mean_kld = kld_sum / float(sample_count)\n return [mean_nll, mean_kld]\n return fe_term_estimator","def removeFixedEffect(self, index=None):\n if self._n_terms==0:\n pass\n if index is None or index==(self._n_terms-1):\n\n self._n_terms-=1\n F = self._F.pop() #= self.F[:-1]\n A = self._A.pop() #= self.A[:-1]\n self._A_identity.pop() #= self.A_identity[:-1]\n REML_term = self._REML_term.pop()# = self.REML_term[:-1]\n self._B.pop()# = self.B[:-1]\n self._n_fixed_effs-=F.shape[1]*A.shape[0]\n if REML_term:\n self._n_fixed_effs_REML-=F.shape[1]*A.shape[0]\n\n pass\n elif index >= self.n_terms:\n raise Exception(\"index exceeds max index of terms\")\n else:\n raise NotImplementedError(\"currently only last term can be removed\")\n pass\n self._rebuild_indicator()\n self.clear_cache('Fstar','Astar','Xstar','Xhat',\n 'Areml','Areml_eigh','Areml_chol','Areml_inv','beta_hat','B_hat',\n 'LRLdiag_Xhat_tens','Areml_grad',\n 'beta_grad','Xstar_beta_grad','Zstar','DLZ')","def addObjFxnTerm(model, A, x, b, wt, n_aux, name, lb=0):\n import gurobipy as gb\n Ax = model.addMVar(n_aux, vtype=gb.GRB.CONTINUOUS, lb=lb, name=name)\n model.addConstr(A @ x == Ax, name=f\"{name}_cons\") # Constrain the Ax auxiliary variable to be equal to query answer\n #return wt * (Ax @ Ax - 2 * b @ Ax) # Quadratic obj_fxn terms for query answers: wt * (Ax - b)^2, constant dropped\n return (Ax @ wt @ Ax - 2 * b @ wt @ Ax) # Quadratic obj_fxn terms for query answers: wt * (Ax - b)^2, constant dropped","def buildWPriorTerm(self):\r\n\r\n # self.w_prior.shape == (minibatch size,)\r\n self.w_prior = 0.5*T.sum(1 + T.log(self.qwgy_var) - self.qwgy_mu**2-self.qwgy_var, axis=1)\r\n\r\n self.w_prior_modif = - T.maximum(self.hyper['treshold_w_prior'], -self.w_prior)","def reset_hessian_and_bias(self):\n # reset_shared_var(self.t_H)\n t = self.QUAD_REG\n if len(t.shape) == 1:\n self.t_H.set_value(np.diag(self.QUAD_REG))\n elif len(t.shape) == 2:\n self.t_H.set_value(self.QUAD_REG)\n else:\n raise ValueError('Invalid quad_reg shape')\n\n reset_shared_var(self.t_B)","def _initialize_bounds(problem, bounds, get_bound, set_bound):\n for constraint in problem.constraints:\n root_expr = constraint.root_expr\n expr_bounds = Interval(constraint.lower_bound, constraint.upper_bound)\n if root_expr not in bounds:\n set_bound(root_expr, expr_bounds)\n else:\n existing_bounds = get_bound(root_expr)\n new_bounds = existing_bounds.intersect(expr_bounds)\n set_bound(root_expr, new_bounds)","def forces(self):\n pass","def epflux_eddyterms():\n pass","def preprocess(self):\n\n if self.x_range == None:\n x_min = min(np.min(self.fx), np.min(self.gx))\n x_max = max(np.max(self.fx), np.max(self.gx))\n self.x_range = [x_min,x_max]\n\n f_inter = interpolate.interp1d(self.fx, self.fy, 'cubic', fill_value = 'extrapolate')\n g_inter = interpolate.interp1d(self.gx, self.gy, 'cubic', fill_value = 'extrapolate')\n fgx_new = np.linspace(self.x_range[0], self.x_range[1], self.N)\n fy_new = f_inter(fgx_new)\n gy_new = g_inter(fgx_new)\n\n self.fx, self.fy = fgx_new, fy_new\n self.gx, self.gy = fgx_new, gy_new","def calc(self):\n\n # the following if query ensures that volume- and interaction-terms\n # are only calculated if tau > 0.\n # (to avoid nan-values from invalid function-evaluations)\n\n if self.V.tau.shape == (1,):\n Isurf = self.surface()\n # differentiation for non-existing canopy, as otherwise NAN values\n if self.V.tau > 0.:\n Ivol = self.volume()\n if self.int_Q is True:\n Iint = self.interaction()\n else:\n Iint = np.array([0.])\n else:\n Ivol = np.array([0.])\n Iint = np.array([0.])\n else:\n # calculate surface-term (valid for any tau-value)\n Isurf = self.surface()\n\n # store initial parameter-values\n old_t_0 = self.t_0\n old_p_0 = self.p_0\n old_t_ex = self.t_ex\n old_p_ex = self.p_ex\n\n old_tau = self.V._get_tau()\n old_omega = self.V._get_omega()\n old_NN = self.SRF._get_NormBRDF()\n\n # set mask for tau > 0.\n mask = old_tau > 0.\n valid_index = np.where(mask)\n inval_index = np.where(~mask)\n\n # set parameter-values to valid values for calculation\n self.t_0 = old_t_0[valid_index[0]]\n self.p_0 = old_p_0[valid_index[0]]\n self.t_ex = old_t_ex[valid_index[0]]\n self.p_ex = old_p_ex[valid_index[0]]\n\n # squeezing the arrays is necessary since the setter-function for\n # tau, omega and NormBRDF automatically adds an axis to the arrays!\n self.V.tau = np.squeeze(old_tau[valid_index[0]])\n if np.array(self.V.omega).size != 1:\n self.V.omega = np.squeeze(old_omega[valid_index[0]])\n if np.array(self.SRF.NormBRDF).size != 1:\n self.SRF.NormBRDF = np.squeeze(old_NN[valid_index[0]])\n\n # calculate volume and interaction term where tau-values are valid\n _Ivol = self.volume()\n if self.int_Q is True:\n _Iint = self.interaction()\n else:\n _Iint = np.full_like(self.t_0, 0.)\n\n # reset parameter values to old values\n self.t_0 = old_t_0\n self.p_0 = old_p_0\n self.t_ex = old_t_ex\n self.p_ex = old_p_ex\n\n # squeezing the arrays is necessary since the setter-function for\n # tau, omega and NormBRDF automatically add an axis to the arrays!\n self.V.tau = np.squeeze(old_tau)\n self.V.omega = np.squeeze(old_omega)\n self.SRF.NormBRDF = np.squeeze(old_NN)\n\n # combine calculated volume-contributions for valid tau-values\n # with zero-arrays for invalid tau-values\n Ivol = np.ones_like(self.t_0)\n Ivol[valid_index[0]] = _Ivol\n Ivol[inval_index[0]] = np.ones_like(Ivol[inval_index[0]]) * 0.\n\n # combine calculated interaction-contributions for valid tau-values\n # with zero-arrays for invalid tau-values\n if self.int_Q is True:\n Iint = np.ones_like(self.t_0)\n Iint[valid_index[0]] = _Iint\n Iint[inval_index[0]] = np.ones_like(Iint[inval_index[0]]) * 0.\n else:\n Iint = np.full_like(self.t_0, 0.)\n\n return Isurf + Ivol + Iint, Isurf, Ivol, Iint","def _redef_sp1_vars(self):\r\n\r\n if len(self.fq_list) == 0:\r\n no_rad = True\r\n lst_tmp = np.matrix(np.reshape(self.lst_tmp, \r\n (self.lst_tmp.size, 1)))\r\n else: no_rad = False\r\n # The practically constants...\r\n # Big Epsilon:\r\n if self.cond == True:\r\n self.Epsilon = self.d_T * self.thermal_conductivity\r\n else:\r\n self.Epsilon = (self.diff_scale ** 2) / \\\r\n (3.0 * self.absorb_coeffs[self.rad] ** 2)\r\n # Beta:\r\n if self.cond == True:\r\n self.Beta = (self.diff_scale * self.thermal_conductivity) / \\\r\n (self.convect_coeff)\r\n else:\r\n self.Beta = (1.0 + 3.0 * self.r2) * (2.0 * self.diff_scale) / \\\r\n ((1.0 - 2.0 * self.r1) * (\r\n 3.0 * self.absorb_coeffs[self.rad]))\r\n\r\n # The feild solutions at the last timestep.\r\n # The integral vF:\r\n if self.cond == True:\r\n # The horrifically complicated F:\r\n def F_func_cond(elem, eta):\r\n F = 0.0\r\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n F += Tn\r\n for k in range(0, len(self.fq_list)):\r\n vk = self.fq_list[k]\r\n try:\r\n vk_m = self.fq_list[k - 1]\r\n except:\r\n vk_m = self.v0_frequency\r\n absorbtion = self.absorb_coeffs[k]\r\n phi = elem.eval_elem(self.node_map, self.lst_rad[k],\r\n [eta])[0]\r\n inter1 = phi - 4.0 * sconst.pi * \\\r\n self.B_int_function(Tn, self.refr_idx_vol,\r\n vk, vk_m)\r\n inter2 = absorbtion * self.d_T / (self.diff_scale ** 2)\r\n F += inter2 * inter1\r\n return elem.funcs(eta) * F\r\n if not no_rad:\r\n # We're integrating something non-linear for SP1\r\n self.vF_vect_vol = et.elems_2_array(self.mesh,\r\n F_func_cond,\r\n self.node_map)\r\n else:\r\n # Or something easier if we're only looking at heat.\r\n self.vF_vect_vol = np.array(self.uv_vol * lst_tmp).reshape(-1)\r\n else:\r\n def F_func_radiative(elem, eta):\r\n T = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n vk = self.fq_list[self.rad]\r\n try:\r\n vk_minus = self.fq_list[self.rad - 1]\r\n except:\r\n vk_minus = self.v0_frequency\r\n n = self.refr_idx_vol\r\n F = 4.0 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\r\n return elem.funcs(eta) * F\r\n\r\n self.vF_vect_vol = et.elems_2_array(self.mesh,\r\n F_func_radiative,\r\n self.node_map)\r\n # The path integral vf:\r\n if self.cond == True:\r\n def f_func_cond(elem, eta):\r\n Tb = self.background_temperature\r\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n n = self.refr_idx_background\r\n vk = self.v0_frequency\r\n vk_minus = 0\r\n Bb0 = self.B_int_function(Tb, n, vk, vk_minus)\r\n Bn0 = self.B_int_function(Tn, n, vk, vk_minus)\r\n B_coeff = (self.alpha * sconst.pi) / self.convect_coeff\r\n f = Tb + B_coeff * (Bb0 - Bn0)\r\n return elem.funcs(eta) * f\r\n if not no_rad:\r\n self.vf_vect_bound = et.edge_2_array(self.mesh,\r\n \"Boundary\",\r\n f_func_cond,\r\n self.node_map)\r\n else:\r\n try:\r\n self.vf_vect_bound = self.cache_tb_integral_array\r\n except AttributeError:\r\n def elem_functor(elem, eta): return elem.funcs(eta)\r\n self.cache_tb_integral_array = et.edge_2_array(self.mesh,\r\n \"Boundary\",\r\n elem_functor,\r\n self.node_map)\r\n self.cache_tb_integral_array *= self.background_temperature\r\n self.vf_vect_bound = self.cache_tb_integral_array\r\n \r\n else:\r\n # Radiation f = 4*pi*B^{(k)}(T_b, n_g)\r\n def f_func_radiative(elem, eta):\r\n T = self.background_temperature\r\n vk = self.fq_list[self.rad]\r\n try:\r\n vk_minus = self.fq_list[self.rad - 1]\r\n except:\r\n vk_minus = self.v0_frequency\r\n n = self.refr_idx_vol\r\n f = 4 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\r\n return elem.funcs(eta) * f\r\n\r\n self.vf_vect_bound = et.edge_2_array(self.mesh,\r\n \"Boundary\",\r\n f_func_radiative,\r\n self.node_map)\r\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\r\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\r\n assert (self.vf_vect_bound.shape[0] == \\\r\n self.vF_vect_vol.shape[0])","def eventually(self, t1, t2):\n new_robustness = lambda s, t : max([ self.robustness(s,k) for k in range(t+t1, t+t2+1)])\n\n new_formula = STLFormula(new_robustness)\n\n return new_formula","def _manage_infinity_bounds(problem, _bounds, get_bound, set_bound):\n for variable in problem.variables:\n expr_bounds = get_bound(variable)\n lower_bound = expr_bounds.lower_bound\n upper_bound = expr_bounds.upper_bound\n\n if is_inf(lower_bound):\n new_lower_bound = None\n else:\n new_lower_bound = lower_bound\n\n if is_inf(upper_bound):\n new_upper_bound = None\n else:\n new_upper_bound = upper_bound\n\n set_bound(variable, Interval(new_lower_bound, new_upper_bound))","def calculateExteriorElementBoundaryQuadrature(self):\n #\n #get physical locations of element boundary quadrature points\n #\n #assume all components live on the same mesh\n self.u[0].femSpace.elementMaps.getValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\n self.ebqe['x'])\n #\n #get metric tensor and unit normals\n #\n if self.movingDomain:\n if self.tLast_mesh != None:\n self.ebqe['xt'][:]=self.ebqe['x']\n self.ebqe['xt']-=self.ebqe['x_last']\n alpha = 1.0/(self.t_mesh - self.tLast_mesh)\n self.ebqe['xt']*=alpha\n else:\n self.ebqe['xt'][:]=0.0\n self.ebqe['x_last'][:]=self.ebqe['x']\n self.u[0].femSpace.elementMaps.getJacobianValuesGlobalExteriorTrace_movingDomain(self.elementBoundaryQuadraturePoints,\n self.ebqe['xt'],\n self.ebqe['inverse(J)'],\n self.ebqe['g'],\n self.ebqe['sqrt(det(g))'],\n self.ebqe['n'])\n else:\n self.u[0].femSpace.elementMaps.getJacobianValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\n self.ebqe['inverse(J)'],\n self.ebqe['g'],\n self.ebqe['sqrt(det(g))'],\n self.ebqe['n'])\n #now map the physical points back to the reference element\n #assume all components live on same mesh\n self.u[0].femSpace.elementMaps.getInverseValuesGlobalExteriorTrace(self.ebqe['inverse(J)'],self.ebqe['x'],self.ebqe['hat(x)'])\n #\n #since the points on the reference boundary may be reordered on many right element boundaries, we\n #have to use an array of reference boundary points on all element boundaries\n #first copy the left reference element boundary quadrature points from the reference element boundary\n self.testSpace[0].getBasisValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\n self.ebqe[('w',0)])\n cfemIntegrals.calculateWeightedShapeGlobalExteriorTrace(self.mesh.exteriorElementBoundariesArray,\n self.mesh.elementBoundaryElementsArray,\n self.mesh.elementBoundaryLocalElementBoundariesArray,\n self.elementBoundaryQuadratureWeights[('f',0)],\n self.ebqe['sqrt(det(g))'],\n self.ebqe[('w',0)],\n self.ebqe[('w*dS_f',0)])\n self.u[0].femSpace.getBasisGradientValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\n self.ebqe['inverse(J)'],\n self.ebqe[('grad(v)',0)])\n #setup flux boundary conditions\n self.fluxBoundaryConditionsObjectsDict = dict([(cj,FluxBoundaryConditions(self.mesh,\n self.nElementBoundaryQuadraturePoints_elementBoundary,\n self.ebqe[('x')],\n self.advectiveFluxBoundaryConditionsSetterDict[cj],\n self.diffusiveFluxBoundaryConditionsSetterDictDict[cj]))\n for cj in self.advectiveFluxBoundaryConditionsSetterDict.keys()])\n self.ebqe['dS'] = numpy.zeros((self.mesh.nExteriorElementBoundaries_global,self.nElementBoundaryQuadraturePoints_elementBoundary),'d')\n cfemIntegrals.calculateIntegrationWeights(self.ebqe['sqrt(det(g))'],\n self.elementBoundaryQuadratureWeights[('u',0)],\n self.ebqe['dS'])\n for ci in range(self.nc): self.ebqe[('dS',ci)] = self.ebqe['dS']\n #\n self.ellamDiscretization.calculateExteriorElementBoundaryQuadrature(self.ebqe)\n #\n self.coefficients.initializeGlobalExteriorElementBoundaryQuadrature(self.timeIntegration.t,self.ebqe)","def R_term(\n enst, # enstrophy field\n omega1, # vorticity-1 component\n omega2, # vorticity-2 component\n omega3, # vorticity-3 component\n s11, # strain rate-11 component\n s12, # strain rate-12 component\n s13, # strain rate-13 component\n s22, # strain rate-22 component\n s23, # strain rate-23 component\n s33, # strain rate-33 component\n diff = False): # differentiation flag\n #---------------------------------------------------------------------#\n # Defining domain variables #\n #---------------------------------------------------------------------#\n pi = np.pi # pi\n dx = (2.0*pi)/64.0 # spatial step\n nu = 0.000185 # default viscosity\n #---------------------------------------------------------------------#\n # Spectral differentiation variables #\n #---------------------------------------------------------------------#\n dim = 64\n kspec = np.fft.fftfreq(dim) * dim\n Kfield = np.array(np.meshgrid(kspec, kspec, kspec, indexing='ij'))\n #---------------------------------------------------------------------#\n # Spectral differentiation variables #\n #---------------------------------------------------------------------#\n term1 = np.zeros((dim, dim, dim))\n term2 = np.zeros((dim, dim, dim))\n term3 = np.zeros((dim, dim, dim))\n #---------------------------------------------------------------------#\n # Numerator (numpy gradient tool) #\n #---------------------------------------------------------------------#\n if diff is not False:\n term1 = np.gradient(enst,dx, edge_order=2)[0]\n term2 = np.gradient(enst,dx, edge_order=2)[1]\n term3 = np.gradient(enst,dx, edge_order=2)[2]\n #---------------------------------------------------------------------#\n # Numerator (spectral differentiation) #\n #---------------------------------------------------------------------#\n else:\n term1 = 0.5*np.fft.ifftn(1j*Kfield[0]*np.fft.fftn(enst) +\\\n 1j*Kfield[0]*np.fft.fftn(enst)).real\n term2 = 0.5*np.fft.ifftn(1j*Kfield[1]*np.fft.fftn(enst) +\\\n 1j*Kfield[1]*np.fft.fftn(enst)).real\n term3 = 0.5*np.fft.ifftn(1j*Kfield[2]*np.fft.fftn(enst) +\\\n 1j*Kfield[2]*np.fft.fftn(enst)).real\n #---------------------------------------------------------------------#\n # Numerator #\n #---------------------------------------------------------------------#\n num = nu*(term1**2.0+ term2**2.0 + term3**2.0)\n #---------------------------------------------------------------------#\n # Denominator #\n #---------------------------------------------------------------------#\n den = omega1*s11*omega1 + omega1*s12*omega2 + omega1*s13*omega3 +\\\n omega2*s12*omega1 + omega2*s22*omega2 + omega2*s23*omega3+\\\n omega3*s13*omega1 + omega3*s23*omega2 + omega3*s33*omega3\n #---------------------------------------------------------------------#\n # R calculation #\n #---------------------------------------------------------------------#\n R = num/den\n\n return R","def update_boundary(self):\n\n cell = self._fire_boundary.dequeue()\n neighbors = self.four_neighbors(cell[0], cell[1])\n #neighbors = self.eight_neighbors(cell[0], cell[1])\n for neighbor in neighbors:\n if self.is_empty(neighbor[0], neighbor[1]):\n self.set_full(neighbor[0], neighbor[1])\n self._fire_boundary.enqueue(neighbor)\n\n # Check class invariant after update\n assert self.boundary_invariant()","def do(self, variables, values):\n intervened = LinearGaussianBN()\n sym_values = [Symbol(val) if isinstance(val, str) else val for val in values]\n var_to_value = dict(zip(variables, sym_values))\n for variable in self.variables:\n if variable not in variables:\n new_parents = []\n new_weights = [self._weights[variable][0]]\n for indx, p in enumerate(self.parents(variable)):\n w = self._weights[variable][indx + 1]\n if p not in variables:\n new_parents.append(p)\n new_weights.append(w)\n else:\n new_weights[0] += w * var_to_value[p]\n\n intervened.add_var(variable, new_parents, new_weights)\n\n return intervened","def SetPRCatConstraint(self, model ) :\n tot = np.multiply(self.wish, self.dispo)\n for line in tot :\n for val in line :\n if not val : continue\n if self.bound>0 : model += val <= self.valBound\n elif self.bound<0 : model += val >= self.valBound","def terms(self, terms):\n\n self._terms = terms","def set_weight(term, irrelevant):\n if term in irrelevant:\n return (0.2 * max([x/sum(indtf_features[term]) for x in indtf_features[term]]))\n elif isinstance(term, tuple):\n return len(term)\n else:\n return 1","def _compute_forces(self):\n # get new coeffs\n self._get_coeffs()\n\n # instead of writing many time\n awa = self.awa / 180.0 * np.pi\n\n # lift and drag\n self.lift = 0.5 * self.rho * self.aws ** 2 * self.area * self.cl\n self.drag = 0.5 * self.rho * self.aws ** 2 * self.area * self.cd + self._get_Rw(awa)\n\n # project into yacht coordinate system\n self.Fx = self.lift * np.sin(awa) - self.drag * np.cos(awa)\n self.Fy = self.lift * np.cos(awa) + self.drag * np.sin(awa)\n\n # heeling moment\n self.Mx = self.Fy * self._vce() * np.cos(self.phi / 180.0 * np.pi)\n\n # side-force is horizontal component of Fh\n self.Fy *= np.cos(np.deg2rad(self.phi))","def initialize_constants(self):\n # maximum pheromone value\n self.PH_MAX = np.float_( len(self.variables) / (1.0 - self.PH_REDUCE_FACTOR))\n # minimum pheromone value\n self.PH_MIN = np.float_(self.PH_MAX / (2*len(self.variables)) )","def _solve_freq_rb(self, d, v, a, force, freqw, freqw2, incrb, unc):\n if self.rbsize and incrb:\n rb = self.rb\n if self.m is not None:\n if unc:\n a_rb = self.invm[self._rb] * force[rb]\n else:\n a_rb = la.lu_solve(self.imrb, force[rb], check_finite=False)\n else:\n a_rb = force[rb]\n if \"d\" in incrb or \"v\" in incrb:\n pvnz = freqw != 0\n if \"v\" in incrb:\n v[rb, pvnz] = (-1j / freqw[pvnz]) * a_rb[:, pvnz]\n if \"d\" in incrb:\n d[rb, pvnz] = (-1.0 / freqw2[pvnz]) * a_rb[:, pvnz]\n if \"a\" in incrb:\n a[rb] = a_rb","def test_basic_handling_range_with_variable_bounds(spark_ctx):\n\n dr = Drudge(spark_ctx)\n\n j1, j2 = symbols('j1 j2')\n m1, m2 = symbols('m1, m2')\n j_max = symbols('j_max')\n j = Range('j', 0, j_max)\n m = Range('m')\n dr.set_dumms(j, [j1, j2])\n dr.set_dumms(m, [m1, m2])\n\n v = Vec('v')\n x = IndexedBase('x')\n tensor = dr.sum((j2, j), (m2, m[0, j2]), x[j2, m2] * v[j2, m2])\n\n reset = tensor.reset_dumms()\n assert reset.n_terms == 1\n term = reset.local_terms[0]\n assert len(term.sums) == 2\n if term.sums[0][1].label == 'j':\n j_sum, m_sum = term.sums\n else:\n m_sum, j_sum = term.sums\n assert j_sum[0] == j1\n assert j_sum[1].args == j.args\n assert m_sum[0] == m1\n assert m_sum[1].label == 'm'\n assert m_sum[1].lower == 0\n assert m_sum[1].upper == j1 # Important!\n assert term.amp == x[j1, m1]\n assert term.vecs == (v[j1, m1],)\n\n # Test that functions can be mapped to the bounds.\n repled = reset.map2scalars(\n lambda x: x.xreplace({j_max: 10}), skip_ranges=False\n )\n assert repled.n_terms == 1\n term = repled.local_terms[0]\n checked = False\n for _, i in term.sums:\n if i.label == 'j':\n assert i.lower == 0\n assert i.upper == 10\n checked = True\n continue\n assert checked","def force ( r, e ):\n from math import isclose\n\n # Parameters of the Gay-Berne potential \n # \n # The key parameters are \n # mu, nu ................ the exponents \n # kappa and kappa' ....... the anisotropies \n # kappa is the ratio of intermolecular separations \n # sigma_e / sigma_s i.e. end-to-end / side-by-side \n # kappa' is the ratio of well depths \n # epsilon_s / epsilon_e i.e. side-by-side / end-to-end \n # The derived parameters are chi and chi' \n # chi = (kappa**2 - 1) / (kappa**2+1) \n # chi' = (z - 1) / (z + 1)\n # where z = (kappa') ** ( 1 / mu ) \n # \n # For convenience kappa' is spelt xappa, chi' is spelt xhi\n # We choose units such that sigma_s = 1.0 and epsilon_0 = 1.0\n # Two of the following three varieties should be commented out\n\n # Original Gay-Berne-deMiguel potential [J. Chem. Phys, 74, 3316; Mol. Phys. 74, 405 (1991)]\n mu, nu, kappa, xappa = 2, 1, 3.0, 5.0\n\n # # Luckhurst-Phippen potential [Liq. Cryst., 8, 451 (1990)]\n # mu, nu, kappa, xappa = 1, 2, 3.0, 5.0\n\n # # Berardi-Zannoni potential [J. Chem. Soc. Faraday Trans., 89, 4069 (1993)]\n # mu, nu, kappa, xappa = 1, 3, 3.0, 5.0\n\n # Derived parameters\n chi = (kappa**2 - 1.0) / (kappa**2+1.0)\n xhi = (xappa**(1.0/mu) - 1.0) / (xappa**(1.0/mu) + 1.0)\n\n # Cutoff distance; normally we would use a larger value\n r_cut = 4.0\n \n assert r.shape == (n,3), 'Incorrect shape of r'\n assert e.shape == (n,3), 'Incorrect shape of e'\n\n # Notation to match appendix\n i = 0\n j = 1\n\n ei = e[i,:]\n ej = e[j,:]\n assert isclose(np.sum(ei**2),1.0), 'Non-unit vector {} {} {}'.format(*ei)\n assert isclose(np.sum(ej**2),1.0), 'Non-unit vector {} {} {}'.format(*ej)\n\n rij = r[i,:] - r[j,:]\n rij_mag = np.sqrt( np.sum(rij**2) ) # Magnitude of separation vector\n sij = rij / rij_mag # Unit vector\n ci = np.dot( ei, sij )\n cj = np.dot( ej, sij )\n cij = np.dot( ei, ej )\n cp = ci + cj\n cm = ci - cj\n\n # Sigma formula\n cpchi = cp/(1.0+chi*cij)\n cmchi = cm/(1.0-chi*cij)\n sigma = 1.0/np.sqrt(1.0-0.5*chi*(cp*cpchi+cm*cmchi))\n\n # Epsilon formula\n eps1 = 1.0/np.sqrt(1.0-(chi*cij)**2) # Depends on chi, not xhi\n cpxhi = cp/(1.0+xhi*cij)\n cmxhi = cm/(1.0-xhi*cij)\n eps2 = 1.0-0.5*xhi*(cp*cpxhi+cm*cmxhi) # Depends on xhi\n epsilon = (eps1**nu) * (eps2**mu)\n\n # Potential at rij\n rho = rij_mag - sigma + 1.0\n rho6 = 1.0 / rho**6\n rho12 = rho6**2\n rhoterm = 4.0*(rho12 - rho6) # Needed for forces and torques\n drhoterm = -24.0 * (2.0 * rho12 - rho6) / rho # Needed for forces and torques\n pot = epsilon*rhoterm\n\n # Potential at r_cut\n rho = r_cut - sigma + 1.0\n rho6 = 1.0 / rho**6\n rho12 = rho6**2\n cutterm = 4.0*(rho12 - rho6) # Needed for cutoff forces and torques\n dcutterm = -24.0 * (2.0 * rho12 - rho6) / rho # Needed for cutoff forces and torques\n pot = pot - epsilon * cutterm\n\n # Derivatives of sigma\n prefac = 0.5*chi*sigma**3\n dsig_dci = prefac*(cpchi+cmchi)\n dsig_dcj = prefac*(cpchi-cmchi)\n prefac = prefac*(0.5*chi)\n dsig_dcij = -prefac*(cpchi**2-cmchi**2)\n\n # Derivatives of epsilon\n prefac = -mu*xhi*(eps1**nu)*eps2**(mu-1)\n deps_dci = prefac*(cpxhi+cmxhi)\n deps_dcj = prefac*(cpxhi-cmxhi)\n prefac = prefac*(0.5*xhi)\n deps_dcij = -prefac*(cpxhi**2-cmxhi**2) # From derivative of eps2\n deps_dcij = deps_dcij + nu*(chi**2)*(eps1**(nu+2))*(eps2**mu)*cij # From derivative of eps1\n\n # Derivatives of potential\n dpot_drij = epsilon * drhoterm\n dpot_dci = rhoterm * deps_dci - epsilon * drhoterm * dsig_dci\n dpot_dcj = rhoterm * deps_dcj - epsilon * drhoterm * dsig_dcj\n dpot_dcij = rhoterm * deps_dcij - epsilon * drhoterm * dsig_dcij\n\n # Standard formula for forces and torque gradients\n fij = -dpot_drij*sij - dpot_dci*(ei-ci*sij)/rij_mag - dpot_dcj*(ej-cj*sij)/rij_mag\n gi = dpot_dci*sij + dpot_dcij*ej\n gj = dpot_dcj*sij + dpot_dcij*ei\n\n # Derivatives of potential at cutoff\n dpot_drij = epsilon * dcutterm\n dpot_dci = cutterm * deps_dci - epsilon * dcutterm * dsig_dci\n dpot_dcj = cutterm * deps_dcj - epsilon * dcutterm * dsig_dcj\n dpot_dcij = cutterm * deps_dcij - epsilon * dcutterm * dsig_dcij\n\n # Standard formula for forces and torque gradients (without dpot_drij term)\n fij = fij + dpot_dci*(ei-ci*sij)/rij_mag + dpot_dcj*(ej-cj*sij)/rij_mag\n gi = gi - ( dpot_dci*sij + dpot_dcij*ej ) \n gj = gj - ( dpot_dcj*sij + dpot_dcij*ei ) \n\n # Final forces and torques\n f = np.empty_like(r)\n t = np.empty_like(r)\n f[i,:] = fij\n f[j,:] = -fij\n t[i,:] = -np.cross(ei,gi)\n t[j,:] = -np.cross(ej,gj)\n\n return pot, f, t","def wang(G, term1, term2):\n if term1 not in G or term2 not in G:\n return 0\n sa = s_values(G, term1)\n sb = s_values(G, term2)\n sva = sum(sa.values())\n svb = sum(sb.values())\n common = set(sa.keys()) & set(sb.keys())\n cv = sum(sa[c] + sb[c] for c in common)\n return round(cv / (sva + svb), 3)","def calculate_boundaries(self, latmesh=False, mask=None, lat_mask=None,\n adot=None, U_mask=None, mark_divide=False):\n s = \"::: calculating boundaries :::\"\n print_text(s, cls=self)\n\n if lat_mask == None and mark_divide:\n s = \">>> IF PARAMETER <mark_divide> OF calculate_boundaries() IS \" + \\\n \"TRUE, PARAMETER <lat_mask> MUST BE AN EXPRESSION FOR THE LATERAL\" + \\\n \" BOUNDARIES <<<\"\n print_text(s, 'red', 1)\n sys.exit(1)\n \n # this function contains markers which may be applied to facets of the mesh\n self.ff = FacetFunction('size_t', self.mesh)\n self.ff_acc = FacetFunction('size_t', self.mesh)\n self.cf = CellFunction('size_t', self.mesh)\n dofmap = self.Q.dofmap()\n\n S = self.S\n B = self.B\n \n # default to all grounded ice :\n if mask == None:\n mask = Expression('1.0', element=self.Q.ufl_element())\n \n # default to all positive accumulation :\n if adot == None:\n adot = Expression('1.0', element=self.Q.ufl_element())\n \n # default to U observations everywhere :\n if U_mask == None:\n U_mask = Expression('1.0', element=self.Q.ufl_element())\n\n self.init_adot(adot)\n self.init_mask(mask)\n self.init_U_mask(U_mask)\n\n if mark_divide:\n s = \" - marking the interior facets for incomplete meshes -\"\n print_text(s, cls=self)\n self.init_lat_mask(lat_mask)\n\n self.S.set_allow_extrapolation(True)\n self.B.set_allow_extrapolation(True)\n self.mask.set_allow_extrapolation(True)\n self.adot.set_allow_extrapolation(True)\n self.U_mask.set_allow_extrapolation(True)\n self.lat_mask.set_allow_extrapolation(True)\n \n tol = 1e-6\n \n s = \" - marking boundaries - \"\n print_text(s, cls=self)\n\n if latmesh:\n s = \" - using a lateral surface mesh - \"\n print_text(s, cls=self)\n \n class GAMMA_S_GND(SubDomain):\n def inside(self, x, on_boundary):\n return mask(x[0], x[1], x[2]) <= 1.0 and on_boundary\n gamma_s_gnd = GAMMA_S_GND()\n\n class GAMMA_S_FLT(SubDomain):\n def inside(self, x, on_boundary):\n return mask(x[0], x[1], x[2]) > 1.0 and on_boundary\n gamma_s_flt = GAMMA_S_FLT()\n\n class GAMMA_U_GND(SubDomain):\n def inside(self, x, on_boundary):\n return abs(x[2] - S(x[0], x[1], x[2])) < tol \\\n and mask(x[0], x[1], x[2]) <= 1.0 \\\n and U_mask(x[0], x[1], x[2]) <= 0.0 and on_boundary\n gamma_u_gnd = GAMMA_U_GND()\n\n class GAMMA_U_FLT(SubDomain):\n def inside(self, x, on_boundary):\n return abs(x[2] - S(x[0], x[1], x[2])) < tol \\\n and mask(x[0], x[1], x[2]) > 1.0 \\\n and U_mask(x[0], x[1], x[2]) <= 0.0 and on_boundary\n gamma_u_flt = GAMMA_U_FLT()\n\n class GAMMA_B_GND(SubDomain):\n def inside(self, x, on_boundary):\n return abs(x[2] - B(x[0], x[1], x[2])) < tol \\\n and mask(x[0], x[1], x[2]) <= 1.0 and on_boundary\n gamma_b_gnd = GAMMA_B_GND()\n\n class GAMMA_B_FLT(SubDomain):\n def inside(self, x, on_boundary):\n return abs(x[2] - B(x[0], x[1], x[2])) < tol \\\n and mask(x[0], x[1], x[2]) > 1.0 and on_boundary\n gamma_b_flt = GAMMA_B_FLT()\n\n class GAMMA_L_OVR(SubDomain):\n def inside(self, x, on_boundary):\n return x[2] > -10 and x[2] < S(x[0], x[1], x[2]) - tol and on_boundary\n gamma_l_ovr = GAMMA_L_OVR()\n\n class GAMMA_L_UDR(SubDomain):\n def inside(self, x, on_boundary):\n return x[2] < 10 and x[2] < S(x[0], x[1], x[2]) - tol and on_boundary\n gamma_l_udr = GAMMA_L_UDR()\n\n class GAMMA_L_TRM(SubDomain):\n def inside(self, x, on_boundary):\n return lat_mask(x[0], x[1], x[2]) <= 0.0\n gamma_l_trm = GAMMA_L_TRM()\n\n gamma_s_flt.mark(self.ff, self.GAMMA_S_FLT)\n gamma_s_gnd.mark(self.ff, self.GAMMA_S_GND)\n gamma_l_ovr.mark(self.ff, self.GAMMA_L_OVR)\n gamma_l_udr.mark(self.ff, self.GAMMA_L_UDR)\n gamma_b_flt.mark(self.ff, self.GAMMA_B_FLT)\n gamma_b_gnd.mark(self.ff, self.GAMMA_B_GND)\n #gamma_u_flt.mark(self.ff, self.GAMMA_U_FLT)\n #gamma_u_gnd.mark(self.ff, self.GAMMA_U_GND)\n #if mark_divide: \n # gamma_l_trm.mark(self.cf, 1)\n \n else :\n s = \" - not using a lateral surface mesh - \"\n print_text(s, cls=self)\n\n class GAMMA_GND(SubDomain):\n def inside(self, x, on_boundary):\n return mask(x[0], x[1], x[2]) <= 1.0\n gamma_gnd = GAMMA_GND()\n\n class GAMMA_FLT(SubDomain):\n def inside(self, x, on_boundary):\n return mask(x[0], x[1], x[2]) > 1.0\n gamma_flt = GAMMA_FLT()\n\n class GAMMA_L_OVR(SubDomain):\n def inside(self, x, on_boundary):\n return x[2] > -10 and on_boundary\n gamma_l_ovr = GAMMA_L_OVR()\n\n class GAMMA_L_UDR(SubDomain):\n def inside(self, x, on_boundary):\n return x[2] < 10 and on_boundary\n gamma_l_udr = GAMMA_L_UDR()\n\n gamma_flt.mark(self.cf, 1)\n gamma_gnd.mark(self.cf, 0)\n gamma_l_ovr.mark(self.ff, self.GAMMA_L_OVR)\n gamma_l_udr.mark(self.ff, self.GAMMA_L_UDR)\n \n # mark the divide if desired : \n if mark_divide:\n class GAMMA_L_DVD(SubDomain):\n def inside(self, x, on_boundary):\n return lat_mask(x[0], x[1], x[2]) <= 0.0 and on_boundary\n gamma_l_dvd = GAMMA_L_DVD()\n gamma_l_dvd.mark(self.ff, self.GAMMA_L_DVD)\n \n s = \" - done - \"\n print_text(s, cls=self)\n \n #s = \" - iterating through %i cells - \" % self.num_cells\n #print_text(s, cls=self)\n #for c in cells(self.mesh):\n # x_m = c.midpoint().x()\n # y_m = c.midpoint().y()\n # z_m = c.midpoint().z()\n # mask_xy = mask(x_m, y_m, z_m)\n\n # if mask_xy > 1:\n # self.cf[c] = 1\n # else:\n # self.cf[c] = 0\n\n #s = \" - done - \"\n #print_text(s, cls=self)\n\n self.ds = Measure('ds')[self.ff]\n self.dx = Measure('dx')#[self.cf]\n \n self.dx_g = self.dx(0) # internal above grounded\n self.dx_f = self.dx(1) # internal above floating\n self.dBed_g = self.ds(3) # grounded bed\n self.dBed_f = self.ds(5) # floating bed\n self.dBed = self.ds(3) + self.ds(5) # bed\n self.dSrf_gu = self.ds(8) # grounded with U observations\n self.dSrf_fu = self.ds(9) # floating with U observations\n self.dSrf_u = self.ds(8) + self.ds(9) # surface with U observations\n self.dSrf_g = self.ds(2) + self.ds(8) # surface of grounded ice\n self.dSrf_f = self.ds(6) + self.ds(9) # surface of floating ice\n self.dSrf = self.ds(6) + self.ds(2) \\\n + self.ds(8) + self.ds(9) # surface\n self.dLat_d = self.ds(7) # lateral divide\n self.dLat_to = self.ds(4) # lateral terminus overwater\n self.dLat_tu = self.ds(10) # lateral terminus underwater\n self.dLat_t = self.ds(4) + self.ds(10) # lateral terminus\n self.dLat = self.ds(4) + self.ds(7) \\\n + self.ds(10) # lateral","def chgvarbound(self,j_,lower_,finite_,value_): # 3\n res = self.__obj.chgvarbound(j_,lower_,finite_,value_)\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)","def add_bcs(self, RHS, bc_left, cff0 ,cff1, cff2):\n RHS[0] += cff0 * self.c[0]/(2*self.dx)*bc_left\n RHS[0] += cff1 * self.c[0]/(2*self.dx)*self.bcs[1]\n RHS[0] += cff2 * self.c[0]/(2*self.dx)*self.bcs[2]","def _para_boosting(self, H):\n # print '----------------primal-dual boost-------------------'\n H = np.hstack((H, -H))\n # H_ft = np.asfortranarray((H.copy()))\n (n, p) = H.shape\n self.c = np.log(n*p)\n nu = int(n * self.ratio)\n\n if self.max_iter < 50:\n delta = 1\n else:\n delta = 40\n d = np.ones(n) / n\n d_bar = np.ones(n) / n\n a_bar = np.ones(p) / p\n a = np.ones(p) / p\n h_a = np.sum(H, axis=1) / p\n h_a_bar = h_a.copy()\n # a_bar = a\n # a_tilde = np.ones(p) / p\n h_a_tilde = h_a.copy()\n # d_tilde = np.zeros(p)\n theta = 1\n sig = 1\n tau = 1\n t = 0\n logscale = 0\n for t in range(self.max_iter):\n d = prox_mapping(h_a_tilde, d, tau, 2)\n if self.has_dcap:\n d2 = proj_cap_ent(d, 1.0 / nu)\n # d_new = d_new/d_new.sum()\n if np.abs(d.sum() - d2.sum()) > 0.0001:\n print 'error'\n d = d2\n d_tilde = d\n dtH = np.dot(d_tilde, H)\n # dtH = np.dot(H.T, d_tilde)\n a_new = prox_mapping(-dtH, a, sig, 2)\n h_a_new = np.dot(H, a_new)\n # a_tilde = a_new + theta * (a_new - a)\n h_a_tilde = (1+theta) * h_a_new - theta * h_a\n a = a_new\n h_a = h_a_new\n d_bar *= t / (t + 1.0)\n d_bar += 1.0 / (t + 1) * d\n a_bar *= t / (t + 1.0)\n a_bar += 1.0 / (t + 1) * a\n # h_a_bar = np.dot(H, a_bar)\n h_a_bar = t / (t + 1.0) * h_a_bar + 1.0/(t+1) * h_a\n if int(np.log(t+1)) == logscale:\n logscale += 1\n self.iter_num.append(t)\n if self.has_dcap:\n min_margin = ksmallest2(h_a_bar, nu)\n self.primal_obj.append(-np.mean(min_margin))\n else:\n self.primal_obj.append(- np.min(h_a_bar))\n self.margin.append(-self.primal_obj[-1])\n self.dual_obj.append(-np.max(np.dot(d_bar, H)))\n self.gap.append(self.primal_obj[-1] - self.dual_obj[-1])\n self.err_tr.append(np.mean(h_a_bar < 0))\n # if t % 100 == 0:\n # print 'iter ' + str(t) + ' ' + str(self.gap[-1])\n if self.gap[-1] < self.epsi:\n break\n self.alpha = a_bar[:p / 2] - a_bar[p / 2:]\n self.d = d_bar\n print \" pd-boosting(python): max iter#%d: , actual iter#%d\" % (self.max_iter, t)","def convergence_check(self):\n air = self.air_alias.val\n flue_gas = self.fuel_alias.val + '_fg'\n fuel = self.fuel_alias.val\n\n for c in self.outl:\n if not c.fluid.val_set[air]:\n if c.fluid.val[air] > 0.95:\n c.fluid.val[air] = 0.95\n if c.fluid.val[air] < 0.5:\n c.fluid.val[air] = 0.5\n\n if not c.fluid.val_set[flue_gas]:\n if c.fluid.val[flue_gas] > 0.5:\n c.fluid.val[flue_gas] = 0.5\n if c.fluid.val[flue_gas] < 0.05:\n c.fluid.val[flue_gas] = 0.05\n\n if not c.fluid.val_set[fuel]:\n if c.fluid.val[fuel] > 0:\n c.fluid.val[fuel] = 0\n\n c.target.propagate_fluid_to_target(c, c.target)\n\n for i in self.inl:\n if i.m.val_SI < 0 and not i.m.val_set:\n i.m.val_SI = 0.01\n\n for c in self.outl:\n if c.m.val_SI < 0 and not c.m.val_set:\n c.m.val_SI = 10\n c.target.propagate_fluid_to_target(c, c.target)\n\n if self.lamb.val < 1 and not self.lamb.is_set:\n self.lamb.val = 2","def _add_unconformity_below(self, feature):\n for f in self.features:\n if f.type == 'series' and feature.feature.name != f.name:\n f.add_region(lambda pos: ~feature.evaluate(pos))\n # for f in reversed(self.features):\n # if f.type == 'unconformity':\n # feature.add_region(lambda pos: f.evaluate(pos))\n # break\n # feature.add_region(lambda pos: ~uc.evaluate(pos))","def add_cp_qe_RBM_terms(K, cons_pot_mesh, quad_geo_mesh):\n num_faces = cons_pot_mesh.get_faces().shape[0]\n x_c = quad_geo_mesh.get_centroid()\n w = quad_geo_mesh.get_w()\n A_m = quad_geo_mesh.get_A_m()\n S_D = quad_geo_mesh.get_surface_area()\n\n for face_num in range(num_faces):\n face_nodes = quad_geo_mesh.get_tri_nodes(face_num)\n face_hs = quad_geo_mesh.get_hs(face_num)\n def v_quad(_xi, _eta, _nodes):\n return np.identity(3)\n v_sub_mat = (1. / S_D) * gq.int_over_tri_quad(v_quad, face_nodes, face_hs)\n def omega_quad(xi, eta, nodes):\n pos = geo.quadratic_interp(xi, eta, nodes)\n X = pos - x_c\n return np.einsum(\"lrs,s->lr\", geo.LC_3, X)\n tmp_omega = gq.int_over_tri_quad(\n omega_quad,\n face_nodes,\n face_hs,\n )\n tmp_arr = []\n for m in range(3):\n tmp_arr.append((1./ A_m[m]) * np.outer(w[m], np.einsum(\"l,ls\", w[m], tmp_omega)))\n tmp_arr = np.array(tmp_arr)\n tmp_omega_mat = np.sum(tmp_arr, axis=0)\n for src_num in range(num_faces):\n K[(3 * src_num):(3 * src_num + 3),\n (3 * face_num):(3 * face_num + 3)] += v_sub_mat\n src_center = cons_pot_mesh.get_node(src_num)\n X_0 = src_center - x_c\n omega_mat = np.einsum(\"ijk,js,k->is\", geo.LC_3, tmp_omega_mat, X_0)\n K[(3 * src_num):(3 * src_num + 3),\n (3 * face_num):(3 * face_num + 3)] += omega_mat","def restrict(self):\n\n cg = self.grid.coarse_like(2)\n\n c_edge_coeffs = EdgeCoeffs(cg, None, empty=True)\n\n c_eta_x = cg.scratch_array()\n c_eta_y = cg.scratch_array()\n\n fg = self.grid\n\n c_eta_x[cg.ilo:cg.ihi+2,cg.jlo:cg.jhi+1] = \\\n 0.5*(self.x[fg.ilo:fg.ihi+2:2,fg.jlo :fg.jhi+1:2] +\n self.x[fg.ilo:fg.ihi+2:2,fg.jlo+1:fg.jhi+1:2])\n\n # redo the normalization\n c_edge_coeffs.x = c_eta_x*fg.dx**2/cg.dx**2\n\n c_eta_y[cg.ilo:cg.ihi+1,cg.jlo:cg.jhi+2] = \\\n 0.5*(self.y[fg.ilo :fg.ihi+1:2,fg.jlo:fg.jhi+2:2] +\n self.y[fg.ilo+1:fg.ihi+1:2,fg.jlo:fg.jhi+2:2])\n\n c_edge_coeffs.y = c_eta_y*fg.dy**2/cg.dy**2\n\n return c_edge_coeffs","def _update_conformers(self, cutoff=0.002):\n logger.debug(\"Updating conformers based on occupancy\")\n\n # Check that all arrays match dimensions.\n assert len(self._occupancies) == len(self._coor_set) == len(self._bs)\n\n # Filter all arrays & lists based on self._occupancies\n # NB: _coor_set and _bs are lists (not arrays). We must compress, not slice.\n filterarray = self._occupancies >= cutoff\n self._occupancies = self._occupancies[filterarray]\n self._coor_set = list(itertools.compress(self._coor_set, filterarray))\n self._bs = list(itertools.compress(self._bs, filterarray))\n\n logger.debug(f\"Remaining valid conformations: {len(self._coor_set)}\")","def normalize_bounds(self, bounds):\n scaled_bounds = []\n scalings = []\n intercepts = []\n \n non_fixed_params = []\n \n print(self.device)\n \n for name, domain in self.bounds.items():\n # Get any fixed parmeters\n if type(domain) == int or type(domain) == float:\n # Take note\n self.fixed_parameters.append(name)\n\n # Free parameters\n elif type(domain) == tuple:\n # Bookkeeping\n self.free_parameters.append(name)\n\n # Get scaling\n lower_bound = min(domain)\n upper_bound = max(domain)\n scale = upper_bound - lower_bound\n\n # Transform to [0, 1] domain\n #scaled_bound = {'name': name, 'type': 'continuous', 'domain': (0., 1.)} #torch.adjustment required\n non_fixed_params.append(name)\n \n # Store\n #scaled_bounds.append(scaled_bound)\n scalings.append(scale)\n intercepts.append(lower_bound)\n else:\n raise ValueError(\"Domain bounds not understood\")\n \n n_hyperparams = len(non_fixed_params)\n \n scaled_bounds = cat([zeros(1,n_hyperparams, device = self.device), \n ones(1, n_hyperparams, device = self.device)], 0)\n return scaled_bounds, tensor(scalings, device = self.device, requires_grad = False), tensor(intercepts, device = self.device, requires_grad = False) #torch.adjustment required","def always(self, t1, t2):\n new_robustness = lambda s, t : min([ self.robustness(s,k) for k in range(t+t1, t+t2+1)])\n\n new_formula = STLFormula(new_robustness)\n\n return new_formula","def _bowl_params(self):\n self.vars['bowl_strength'] = self.bowl.strength + \\\n self.vars['beta_min_offset']\n self.vars['q_init'] = self.vars['bowl_strength']\n if self.vars['bowl_strength'] <= self.vars['beta_min_offset']:\n print(\n f\"Bowl overflow -- Set to the minimum value : {self.vars['beta_min_offset']}\")\n # raise ValueError(\"Bowl overflow... strength lower than set tolerance. Modify the tolerance or fix the bug!\")\n self.vars['bowl_strength'] = self.vars['beta_min_offset']\n if self.vars['bowl_strength'] > self.vars['q_max']:\n self.vars['bowl_strength'] = self.vars['q_max']\n\n self.vars['zeta_bowl'] = self.toNeural(self.bowl.center)\n print(f\"Value for Q set to {self.vars['bowl_strength']}\")","def relax(self,n=1):\n # print(\"putin\", self.level.rhs.reshape(-1)[:])\n # print(\"getout\", self.solver(self.level.rhs.reshape(-1)))\n for i in range(n):\n self.level.mid[:] += (self.solver(self.level.rhs.reshape(-1)) -\n self.solver(self.stencil.eval_convolve(\n self.level.evaluable_view(self.stencil)).reshape(-1))).reshape(self.level.mid.shape)","def compute_bounds(self):\n # Note: linear_constraints object has been been populated at this stage\n L_zero_var = []\n \n for constraint in self._linear_constraints.L_linear_constraints:\n lhs_string = constraint[0]\n rhs_string = constraint[1]\n if float(rhs_string)==0:\n #print \"rhs=0: forcing the variables to zero\"\n L_vars = re.split(r'[+-]',lhs_string)\n \n for var in L_vars:\n modform_var = var.strip()\n \n # forcing all the variables in this constraint to be zero\n self._linear_constraints.modform_space.D_PuLP_variables[modform_var] = pulp.LpVariable(modform_var, lowBound=0, upBound=0)\n #print \"var forced to zero: \", modform_var\n L_zero_var.append(modform_var)\n else: #if float(rhs)==0\n continue\n \n if len(L_zero_var)>0:\n print \"\\n####### Variables forced to zero (rhs = 0) ##########\"\n print \"variables forced to zero: \", set(L_zero_var)\n \n feasible_lc = flc.FeasibleLinearConstraints(self._linear_constraints)\n \n feasible_lc.get_feasible_linear_constraints()\n \n feasible_linear_constraints = feasible_lc.feasible_linear_constraints\n \n lp_solver = lps.LinearProgrammingSolver(feasible_linear_constraints)\n \n D_lower_bounds = {}; D_upper_bounds = {}\n \n for v in [self._linear_constraints.modform_space.D_PuLP_variables[k] for k in sorted(self._linear_constraints.modform_space.D_PuLP_variables.keys(), key=gbfunc.natural_keys)]:\n \n if str(v) in L_zero_var:\n D_lower_bounds[str(v)] = '0'\n D_upper_bounds[str(v)] = '0'\n continue\n #end if str(v) in L_zero_var\n \n objective_function_PuLP = v\n \n list_values_minimize = lp_solver.linear_programming_solver(objective_function_PuLP, pulp.LpMinimize)\n D_lower_bounds[str(v)] = \"%.3f\"%round(pulp.value(v),3)\n \n list_values_maximize = lp_solver.linear_programming_solver(objective_function_PuLP, pulp.LpMaximize)\n D_upper_bounds[str(v)] = \"%.3f\"%round(pulp.value(v),3)\n\n #end for v in ..\n\n return((D_lower_bounds, D_upper_bounds))"],"string":"[\n \"def calculateElementBoundaryCoefficients(self):\\n pass\",\n \"def update(self):\\n\\n terms_toRemove = []\\n\\n for termIndex, [term_constantFactor, term_unknowns_attributeAddresses] in enumerate(self.LHS):\\n\\n # Check if coefficient is 0 - then no need to process any of the unknowns since term will be 0 anyways\\n if term_constantFactor == 0:\\n terms_toRemove.append(termIndex)\\n continue # continue to next term, no need to resolve the unknowns of this term since the product will be 0 anyways\\n\\n # Check if any unknowns became known\\n unknowns_toRemove = []\\n for unknown_attributeAddress in term_unknowns_attributeAddresses:\\n attribute = getattr_fromAddress(*unknown_attributeAddress)\\n if isNumeric(attribute):\\n # object.attribute which had previously been identified as unknown now has a value, add it to the constant factor product and remove from the unknowns\\n self.LHS[termIndex][0] *= attribute # multiply it with the constant factor product\\n unknowns_toRemove.append([termIndex, unknown_attributeAddress])\\n for termIndex, unknown_attributeAddress in unknowns_toRemove: # remove unknowns which have become known in the end\\n # removing in the end not to tamper with the iteration of the above loop\\n self.LHS[termIndex][1].remove(unknown_attributeAddress)\\n\\n # Move constants to RHS\\n if self.LHS[termIndex][1] == []:\\n # if term has no unknowns, it is a constant, move to RHS\\n self.RHS -= self.LHS[termIndex][0]\\n self.LHS.pop(termIndex)\\n\\n for termIndex in reversed(terms_toRemove): # reversed - otherwise would tamper with indices of items identified for removal\\n self.LHS.pop(termIndex)\\n\\n self._gatherUnknowns()\",\n \"def boundary_conditions(self):\\n ce = 2 * self.dy * self.g * self.mu * self.m_u / self.kb\\n self.e[0, :] = (4 * self.e[1, :] - self.e[2, :]) / (\\n ce / self.T[0, :] + 3\\n )\\n self.rho[0, :] = (\\n self.e[0, :]\\n * (self.Y - 1)\\n * self.mu\\n * self.m_u\\n / (self.kb * self.T[0, :])\\n )\\n self.u[0, :] = (4 * self.u[1, :] - self.u[2, :]) / 3\\n self.w[0, :] = 0\\n\\n self.e[-1, :] = (4 * self.e[-2, :] - self.e[-3, :]) / (\\n 3 - ce / self.T[-1, :]\\n )\\n self.rho[-1, :] = (\\n self.e[-1, :]\\n * (self.Y - 1)\\n * self.mu\\n * self.m_u\\n / (self.kb * self.T[-1, :])\\n )\\n self.u[-1, :] = (4 * self.u[-2, :] - self.u[-3, :]) / 3\\n self.w[-1, :] = 0\",\n \"def set_internal_boundary_conditions(self, model):\\n\\n def boundary_gradient(left_symbol, right_symbol):\\n pybamm.logger.debug(\\n \\\"Calculate boundary gradient ({} and {})\\\".format(\\n left_symbol, right_symbol\\n )\\n )\\n left_domain = left_symbol.domain[0]\\n right_domain = right_symbol.domain[0]\\n\\n left_mesh = self.spatial_methods[left_domain].mesh[left_domain]\\n right_mesh = self.spatial_methods[right_domain].mesh[right_domain]\\n\\n left_symbol_disc = self.process_symbol(left_symbol)\\n right_symbol_disc = self.process_symbol(right_symbol)\\n\\n return self.spatial_methods[left_domain].internal_neumann_condition(\\n left_symbol_disc, right_symbol_disc, left_mesh, right_mesh\\n )\\n\\n bc_keys = list(self.bcs.keys())\\n\\n internal_bcs = {}\\n for var in model.boundary_conditions.keys():\\n if isinstance(var, pybamm.Concatenation):\\n children = var.orphans\\n\\n first_child = children[0]\\n next_child = children[1]\\n\\n lbc = self.bcs[var][\\\"left\\\"]\\n rbc = (boundary_gradient(first_child, next_child), \\\"Neumann\\\")\\n\\n if first_child not in bc_keys:\\n internal_bcs.update({first_child: {\\\"left\\\": lbc, \\\"right\\\": rbc}})\\n\\n for current_child, next_child in zip(children[1:-1], children[2:]):\\n lbc = rbc\\n rbc = (boundary_gradient(current_child, next_child), \\\"Neumann\\\")\\n if current_child not in bc_keys:\\n internal_bcs.update(\\n {current_child: {\\\"left\\\": lbc, \\\"right\\\": rbc}}\\n )\\n\\n lbc = rbc\\n rbc = self.bcs[var][\\\"right\\\"]\\n if children[-1] not in bc_keys:\\n internal_bcs.update({children[-1]: {\\\"left\\\": lbc, \\\"right\\\": rbc}})\\n\\n self.bcs.update(internal_bcs)\",\n \"def apply_boundary_conditions(self):\\n E = self.__mesh.get_edge_list()\\n\\n # Top and bottom wall Dirichlet bcs (boundary_id = 21)\\n \\n e21_iterator = self.__mesh.edge_iterator(21)\\n\\n self.edge_center_value[e21_iterator[0]:e21_iterator[1]+1] = 0.0 \\n \\n # Left Dirichlet bc (boundary_id = 2)\\n \\n e2_iterator = self.__mesh.edge_iterator(2)\\n\\n b = np.sin(np.pi*self.y_e[e2_iterator[0]:e2_iterator[1]+1])\\n\\n self.edge_center_value[e2_iterator[0]:e2_iterator[1]+1] \\\\\\n = b\\n \\n # Right Neumann bc (Zero flux, boundary_id = 3)\\n \\n e3_iterator = self.__mesh.edge_iterator(3)\\n \\n for i in range(e3_iterator[0], e3_iterator[1]+1):\\n LC = E[i].get_straddling_cells()\\n n = LC.get_global_cell_number() - 1\\n self.edge_center_value[i] = self.cell_centroid_value[n]\",\n \"def increase_right_boundary(self):\\n self.R = self.R + 1.0\\n self.Ne = self.Ne + 1\",\n \"def _add_boundaries(self):\\n logger.info(\\\"add_boundaries: start of method\\\")\\n\\n import scipy.spatial as sptl\\n import scipy.sparse as sprs\\n Lx = self._Lx\\n Ly = self._Ly\\n Lz = self._Lz\\n Np = self.num_pores()\\n btype = self._btype\\n boffset = 0.05\\n\\n #Translate internal pores to each face of domain\\n poffset = np.zeros((7,3))\\n poffset[[2,5],0] = [-Lx, Lx]\\n poffset[[3,4],1] = [-Ly, Ly]\\n poffset[[1,6],2] = [-Lz, Lz]\\n pcoords = pcoords0 = self['pore.coords']\\n for i in np.r_[1:7]:\\n pcoords = np.concatenate((pcoords,pcoords0 + poffset[i,:]),axis=0)\\n\\n #Use some twisted logic to get bval list of + for boundary and - for periodic faces\\n bval = [0, 1, 2, 3, 4, 5, 6]*(np.array([0, btype[2], btype[0], btype[1], btype[1], btype[0], btype[2]])*-2+1)\\n ptype = np.zeros((Np,),dtype=int)\\n for i in np.r_[1:7]:\\n ptype = np.concatenate((ptype,np.ones((Np,),dtype=int)*bval[i]),axis=0)\\n\\n #pnum contains the internal ID number of the boundary pores (for connecting periodic points)\\n pnum = self.pores()\\n pnum = np.tile(pnum,7)\\n\\n Tri = sptl.Delaunay(pcoords)\\n adjmat = sprs.lil_matrix((np.shape(pcoords)[0],np.shape(pcoords)[0]),dtype=int)\\n for i in np.arange(0,np.shape(Tri.simplices)[0]):\\n #Keep only simplices that are fully in real domain\\n adjmat[Tri.simplices[i],Tri.simplices[i]] = 1\\n adjmat = sprs.triu(adjmat,k=1,format=\\\"lil\\\")\\n for i in np.arange(0,Np):\\n #Add periodic throats to the netowrk (if any)\\n tpore2 = pnum[adjmat.rows[i]][ptype[adjmat.rows[i]]<0]\\n tpore1 = np.ones_like(tpore2,dtype=int)*i\\n conns = self['throat.conns']\\n conns = np.concatenate((conns,np.vstack((tpore1,tpore2)).T),axis=0)\\n #Add boundary pores and throats to the network\\n newporetyps = np.unique(ptype[adjmat.rows[i]][ptype[adjmat.rows[i]]>0])\\n newporenums = np.r_[self.num_pores():self.num_pores()+np.size(newporetyps)]\\n tpore2 = newporenums\\n tpore1 = np.ones_like(tpore2,dtype=int)*i\\n conns = np.concatenate((conns,np.vstack((tpore1,tpore2)).T),axis=0)\\n self['throat.conns'] = conns\\n bcoords = np.zeros((7,3),dtype=float)\\n coords = self['pore.coords']\\n bcoords[1,:] = [coords[i,0], coords[i,1], 0-Lz*boffset]\\n bcoords[2,:] = [0-Lx*boffset, coords[i,1], coords[i,2]]\\n bcoords[3,:] = [coords[i,0], -Ly*boffset, coords[i,2]]\\n bcoords[4,:] = [coords[i,0], Ly+Ly*boffset, coords[i,2]]\\n bcoords[5,:] = [Lx+Lx*boffset, coords[i,1], coords[i,2]]\\n bcoords[6,:] = [coords[i,0], coords[i,1], Lz+Lz*boffset]\\n newporecoords = bcoords[newporetyps,:]\\n coords = np.concatenate((coords,newporecoords),axis=0)\\n self['pore.coords'] = coords\\n #Reset number of pores and throats (easier than tracking it)\\n nums = np.r_[0:np.shape(coords)[0]]\\n self['pore.numbering'] = nums\\n self['pore.numbering'] = np.ones((nums[-1]+1,),dtype=bool)\\n nums = np.r_[0:np.shape(conns)[0]]\\n self['throat.numbering'] = nums\\n self['throat.numbering'] = np.ones((nums[-1]+1,),dtype=bool)\\n logger.debug(\\\"add_boundaries: end of method\\\")\",\n \"def update_real_constants(self, diff_bound):\\n self.constants.eq_update_constants(diff_bound)\\n self.coefficients = self.constants.get_coefficients()\\n return\",\n \"def SetPRBinConstraint(self, model ) :\\n tot = np.multiply(self.wish, self.dispo)\\n for val in tot :\\n if not val : continue\\n if self.bound>0 : model += val <= self.valBound\\n elif self.bound<0 : model += val >= self.valBound\",\n \"def reset_boundaries(self):\\n self.L = - np.random.uniform(0.0,1.0)\\n self.R = self.L + 1.0\\n self.Ne = 0.0\\n self.Nc = 0.0\",\n \"def impose_boundary_conditions(self) -> _ImposeBoundaryConditionsResults:\\n\\n stiffness = self.get_stiffness_matrix()\\n force_vector = self.get_force_vector()\\n\\n restrained_dofs = self.get_supported_dofs()\\n\\n for axis in range(2):\\n stiffness = np.delete(\\n stiffness,\\n [dof for dof in restrained_dofs],\\n axis=axis,\\n )\\n\\n force_vector = np.delete(\\n force_vector,\\n [dof for dof in restrained_dofs],\\n axis=0,\\n )\\n\\n return _ImposeBoundaryConditionsResults(\\n stiffness=stiffness,\\n force=force_vector,\\n )\",\n \"def __call__(self, u, dx):\\n ru = self.central(u)\\n for i,b in self.boundaries:\\n if __debug__:\\n self.log.debug(\\n \\\"Applying boundary: i = \\\" + repr(i) + \\\", b = \\\" + repr(b)\\n )\\n ru[i] = b(u, apply_at = i)\\n return ru/(dx**self.order)\",\n \"def update_forces(self):\\r\\n # update all the functions\\r\\n self.compute_gravity()\\r\\n self.compute_tides()\\r\\n self.compute_centrifugal()\\r\\n self.compute_coriolis()\\r\\n\\r\\n # add together the forces into the summation function\\r\\n self.forcing.assign(self.ftides+self.gravity +\\r\\n self.centrifugal+self.coriolis)\",\n \"def boundary(self):\\n answer = self.zero()\\n for k, v in self.items():\\n for idx, cube in enumerate(k):\\n acc_dim = sum((cube_l.dimension for cube_l in k[:idx]))\\n for i in range(cube.dimension):\\n for epsilon in (0, 1):\\n new_cube = cube.face(i, epsilon)\\n new_k = k[:idx] + (new_cube,) + k[idx + 1:]\\n sign_exp = (acc_dim + i + epsilon) % 2\\n answer += answer.create({new_k: v * (-1)**sign_exp})\\n return answer\",\n \"def force ( box, strain, r ):\\n\\n import numpy as np\\n from itertools import product\\n import math\\n \\n # It is assumed that positions are in units where box = 1\\n # Forces are calculated in units where sigma = 1 and epsilon = 1\\n # Lees-Edwards boundaries, in sliding brick arrangement\\n # Flow/gradient/vorticity directions are x/y/z == 0/1/2\\n # Uses neighbour lists\\n\\n n = r.shape[0]\\n\\n # Set up vectors to half the cells in neighbourhood of 3x3x3 cells in cubic lattice\\n # The cells are chosen so that if (d0,d1,d2) appears, then (-d0,-d1,-d2) does not.\\n # The last three cells are extra ones, to cope with the sheared system\\n d = np.array ( [ [ 0, 0, 0], [ 1, 0, 0], [ 1, 0, 1], [-1, 0, 1], [ 0, 0, 1], # 5 cells with d1=0\\n [ 1, 1, -1], [ 1, 1, 0], [ 1, 1, 1], # 3 cells with d0= 1, d1=1\\n [ 0, 1, -1], [ 0, 1, 0], [ 0, 1, 1], # 3 cells with d0= 0, d1=1\\n [-1, 1, -1], [-1, 1, 0], [-1, 1, 1], # 3 cells with d0=-1, d1=1\\n [-2, 1, -1], [-2, 1, 0], [-2, 1, 1] ] ) # 3 cells with d0=-2, d1=1\\n\\n r[:,0] = r[:,0] - np.rint(r[:,1])*strain # Extra correction in box=1 units\\n r = r - np.rint(r) # Ensure all atoms in periodic box\\n \\n sr2_ovr = 1.77 # Overlap threshold (pot > 100)\\n r_cut_box = r_cut / box\\n r_cut_box_sq = r_cut_box ** 2\\n box_sq = box ** 2\\n\\n # Initialize\\n f = np.zeros_like(r)\\n total = PotentialType ( pot=0.0, vir=0.0, pyx=0.0, lap=0.0, ovr=False )\\n\\n # Calculate cell index triplets\\n sc = math.floor(box/r_cut) # Number of cells along box edge\\n assert sc >= 3, 'System is too small for cells' # Guard against box being too small\\n c = np.floor((r+0.5)*sc).astype(np.int_) # N*3 array of cell indices for all atoms\\n assert np.all(c>=0) and np.all(c<sc), 'Index error' # Simplistic \\\"guard\\\" against roundoff\\n\\n shift = math.floor(strain*sc) # Strain measured in cell lengths\\n\\n if fast:\\n \\n # Build list of arrays, each array holding positions of atoms in a cell\\n # At the same time, define a matching set of force arrays in each cell\\n # i and j number the atoms in each cell; we do not refer explicitly to indices in r\\n rc, fc = [], [] # Initially empty lists of positions and forces\\n for ci in product(range(sc),repeat=3): # Triple loop over cells\\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\\n rc.append(r[mask,:]) # Copy atom coordinates into array, add to list\\n fc.append(np.zeros_like(rc[-1])) # Zero corresponding forces, add to list\\n\\n for ci1, rci in enumerate(rc): # Loop over i-cells, getting all atoms in each i-cell as an array\\n ci = np.unravel_index(ci1,(sc,sc,sc)) # Get i-cell triple-indices\\n if rci.size==0: # Handle empty cell\\n continue\\n\\n # Set up correct neighbour cell indices\\n if ci[1]==sc-1: # i-cell is in the top layer\\n dd = d.copy() # Standard list copied, including extra 3 cells\\n dd[5:,0] = d[5:,0] - shift # All those looking up need adjustment in the x direction\\n else: # i-cell is not in top layer\\n dd = d[:-3,:].copy() # Last three extra cells are not needed; shift is not needed\\n \\n for dj in dd: # Loop over neighbouring j-cells\\n cj = ci + dj # Compute neighbour j-cell triple-indices\\n cj1 = np.ravel_multi_index(cj,(sc,sc,sc),mode='wrap') # Convert j-cell to single-index\\n rcj = rc[cj1] # Get atoms in j-cell as an array\\n if rcj.size==0: # Handle empty cell\\n continue\\n\\n rij = rci[:,np.newaxis,:]-rcj[np.newaxis,:,:] # Separation vectors for all i and j\\n rij[:,:,0] = rij[:,:,0] - np.rint(rij[:,:,1])*strain # Extra correction in box=1 units\\n rij = rij - np.rint(rij) # PBCs in box=1 units\\n rij_sq = np.sum(rij**2,axis=2) # Squared separations\\n in_range = rij_sq < r_cut_box_sq # Set flags for within cutoff\\n\\n if ci1==cj1:\\n np.fill_diagonal(in_range,False) # Eliminate i==j when i-cell==j-cell\\n np.fill_diagonal(rij_sq,1.0) # Avoid divide-by-zero below\\n\\n rij_sq = rij_sq * box_sq # Now in sigma=1 units\\n rij = rij * box # Now in sigma=1 units\\n sr2 = np.where ( in_range, 1.0/rij_sq, 0.0 ) # (sigma/rij)**2, only if in range\\n ovr = sr2 > sr2_ovr # Overlap if too close\\n sr6 = sr2 ** 3\\n sr12 = sr6 ** 2\\n pot = sr12 - sr6 # LJ potential (cut but not shifted)\\n vir = pot + sr12 # LJ virial\\n pot = np.where ( in_range, pot+0.25, 0.0 ) # WCA LJ pair potential (cut-and-shifted)\\n lap = ( 22.0*sr12 - 5.0*sr6 ) * sr2 # LJ Laplacian\\n fij = vir * sr2 # LJ scalar part of forces\\n fij = rij * fij[:,:,np.newaxis] # LJ pair forces\\n pyx = rij[:,:,1]*fij[:,:,0] # Off-diagonal element of pressure tensor\\n\\n if ci1==cj1: # Correct for double-counting ij and ji when i-cell==j-cell\\n fij = fij / 2\\n total = total + PotentialType ( pot=np.sum(pot)/2, vir=np.sum(vir)/2, \\n pyx=np.sum(pyx)/2, lap=np.sum(lap)/2, ovr=np.any(ovr) )\\n else:\\n total = total + PotentialType ( pot=np.sum(pot), vir=np.sum(vir), \\n pyx=np.sum(pyx), lap=np.sum(lap), ovr=np.any(ovr) )\\n\\n fc[ci1][:,:] = fc[ci1][:,:] + np.sum(fij,axis=1) # Aggregate force on atoms in i-cell\\n fc[cj1][:,:] = fc[cj1][:,:] - np.sum(fij,axis=0) # Aggregate force on atoms in j-cell\\n\\n # Copy forces from list of cell arrays to main force array\\n for ci in product(range(sc),repeat=3): # Triple loop over cells\\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\\n ci1 = np.ravel_multi_index(ci,(sc,sc,sc),mode='wrap') # Single-index\\n f[mask,:] = fc[ci1] # Copy atom forces from correct cell\\n\\n else:\\n \\n # Build list of arrays, each array holding indices of atoms in a cell\\n # ki and kj are atom indices in the r array; i and j number the atoms in each cell\\n k_array = np.arange(n) # Atom indices 0..N-1\\n kc = [] # Initially empty list of indices\\n for ci in product(range(sc),repeat=3): # Triple loop over cells\\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\\n kc.append(k_array[mask]) # Copy atom indices into array, add to list\\n\\n for ci1, kci in enumerate(kc): # Loop over i-cells, getting atom indices as an array\\n ci = np.unravel_index(ci1,(sc,sc,sc)) # Get i-cell triple-indices\\n\\n # Set up correct neighbour cell indices\\n if ci[1]==sc-1: # i-cell is in the top layer\\n dd = d # Standard list copied, including extra 3 cells\\n dd[5:,0] = dd[5:,0] - shift # All those looking up need adjustment in the x direction\\n else:\\n dd = d[:-3,:] # Last three extra cells are not needed; shift is not needed\\n\\n for dj in dd: # Loop over neighbouring j-cells\\n cj = ci + dj # Compute neighbour j-cell triple-indices\\n cj1 = np.ravel_multi_index(cj,(sc,sc,sc),mode='wrap') # Convert to single-index\\n kcj = kc[cj1] # Get indices of atoms in j-cell as an array\\n\\n for i, ki in enumerate(kci): # Loop over individual atoms in i-cell\\n j0 = i+1 if cj1==ci1 else 0 # Only look upwards if i-cell==j-cell\\n if j0 >= kcj.size: # Handles (redundantly) empty j-cell and the case \\n continue # where j-cell==i-cell and i is last atom\\n\\n for kj in kcj[j0:]: # Loop over individual atoms in j-cell\\n rij = r[ki,:]-r[kj,:] # Separation vector\\n rij[0] = rij[0] - np.rint(rij[1])*strain # Extra correction in box=1 units\\n rij = rij - np.rint(rij) # Periodic boundary conditions in box=1 units\\n rij_sq = np.sum(rij**2) # Squared separation\\n\\n if rij_sq < r_cut_box_sq: # Check within cutoff\\n rij_sq = rij_sq * box_sq # Now in sigma=1 units\\n rij = rij * box # Now in sigma=1 units\\n sr2 = 1.0 / rij_sq # (sigma/rij)**2\\n ovr = sr2 > sr2_ovr # Overlap if too close\\n sr6 = sr2 ** 3\\n sr12 = sr6 ** 2\\n pot = sr12 - sr6 # LJ potential (cut but not shifted)\\n vir = pot + sr12 # LJ virial\\n pot = pot + 0.25 # WCA LJ potential (cut-and-shifted)\\n lap = ( 22.0*sr12 - 5.0*sr6 ) * sr2 # LJ Laplacian\\n fij = rij * vir * sr2 # LJ forces\\n pyx = rij[1]*fij[0] # Off-diagonal element of pressure tensor\\n total = total + PotentialType ( pot=pot, vir=vir, pyx=pyx, lap=lap, ovr=ovr )\\n f[ki,:] = f[ki,:] + fij\\n f[kj,:] = f[kj,:] - fij\\n\\n # Multiply results by numerical factors\\n f = f * 24.0 # 24*epsilon\\n total.pot = total.pot * 4.0 # 4*epsilon\\n total.vir = total.vir * 24.0 / 3.0 # 24*epsilon and divide virial by 3\\n total.pyx = total.pyx * 24.0 # 24*epsilon\\n total.lap = total.lap * 24.0 * 2.0 # 24*epsilon and factor 2 for ij and ji\\n \\n return total, f\",\n \"def _redef_via_predef_eqn(self):\\r\\n time = self.current_T # + self.d_T\\r\\n\\r\\n self.Beta = (self.diff_scale * self.thermal_conductivity) / \\\\\\r\\n (self.convect_coeff) \\r\\n self.Epsilon = self.d_T * self.thermal_conductivity / \\\\\\r\\n (self.density * self.heat_capacity)\\r\\n\\r\\n # Source term.\\r\\n def F_func(elem, eta):\\r\\n x = elem.local_to_global(eta)\\r\\n F = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n F -= self.Epsilon * self.redef_F_laplacian(x[0], x[1], time)\\r\\n F += self.redef_dTdt(x[0], x[1], time) * self.d_T\\r\\n return elem.funcs(eta) * F\\r\\n\\r\\n self.vF_vect_vol = et.elems_2_array(self.mesh,\\r\\n F_func,\\r\\n self.node_map,\\r\\n gauss_mult=2) # Use double gp_1D\\r\\n\\r\\n # Boundary term.\\r\\n def f_func(elem, eta):\\r\\n n = elem.guess_normal_vector_global(eta)\\r\\n f = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n x = elem.local_to_global(eta)\\r\\n # Evaluate our boundary term.\\r\\n f += self.Beta * self.redef_f_norm_grad(x[0], x[1], time, n)\\r\\n f += self.redef_dTdt(x[0], x[1], time) * self.d_T\\r\\n return elem.funcs(eta) * f\\r\\n\\r\\n self.vf_vect_bound = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n f_func,\\r\\n self.node_map,\\r\\n gauss_mult=2)\",\n \"def fix_curvature(self) -> None:\\n self.n1.fix = True\\n self.n2.fix = True\",\n \"def calculateExteriorElementBoundaryCoefficients(self):\\n #\\n #get u and grad(u) at the quadrature points\\n #\\n for ci in range(self.nc):\\n self.u[ci].getValuesGlobalExteriorTrace(self.ebqe[('v',ci)],self.ebqe[('u',ci)])\\n if self.ebqe.has_key(('grad(u)',ci)):\\n self.u[ci].getGradientValuesGlobalExteriorTrace(self.ebqe[('grad(v)',ci)],self.ebqe[('grad(u)',ci)])\\n #\\n #get coefficients at the element boundary quadrature points\\n #\\n self.coefficients.evaluate(t = self.timeIntegration.t, c = self.ebqe)\\n #\\n #time integration, handled directly in ELLAM formulation\\n #\\n #ignore numerical flux for now\\n #if self.numericalFlux != None:\\n # self.numericalFlux.calculateExteriorNumericalFlux(self.inflowFlag,self.q,self.ebqe)\\n #flux boundary conditions specified through advective flux\\n for ci,fbcObject in self.fluxBoundaryConditionsObjectsDict.iteritems():\\n for t,g in fbcObject.advectiveFluxBoundaryConditionsDict.iteritems():\\n self.ebqe[('advectiveFlux_bc',ci)][t[0],t[1]] = g(self.ebqe[('x')][t[0],t[1]],self.timeIntegration.t)\\n self.ebqe[('advectiveFlux_bc_flag',ci)][t[0],t[1]] = 1\",\n \"def set_basis(self, maps, methods):\\n self.eval_method = methods\\n\\n def get_grad(maps, shape):\\n bfref0 = eval_base(maps.qp_coor, diff=True).swapaxes(1, 2)\\n if shape == (1,): # scalar variable\\n bfref = bfref0\\n elif len(shape) == 1: # vector variable\\n vec_shape = nm.array(bfref0.shape + shape)\\n vec_shape[1] *= shape[0]\\n bfref = nm.zeros(vec_shape)\\n for ii in nm.arange(shape[0]):\\n slc = slice(ii*bfref0.shape[1], (ii+1)*bfref0.shape[1])\\n bfref[:, slc, ii] = bfref0\\n else: # higher-order tensors variable\\n msg = \\\"Evaluation of basis has not been implemented \\\\\\n for higher-order tensors yet.\\\"\\n raise NotImplementedError(msg)\\n return bfref\\n\\n def get_val(maps, shape):\\n bfref0 = eval_base(maps.qp_coor, diff=False).swapaxes(1, 2)\\n\\n if self.shape == (1,): # scalar variable\\n bfref = bfref0\\n elif len(shape) == 1:\\n vec_shape = nm.array(bfref0.shape)\\n vec_shape[1:3] *= shape[0]\\n bfref = nm.zeros(vec_shape)\\n for ii in nm.arange(shape[0]):\\n slc = slice(ii*bfref0.shape[1], (ii+1)*bfref0.shape[1])\\n bfref[:, slc] = bfref0\\n else: # higher-order tensors variable\\n msg = \\\"Evaluation of basis has not been implemented \\\\\\n for higher-order tensors yet.\\\"\\n raise NotImplementedError(msg)\\n return bfref\\n\\n eval_base = self.interp.poly_spaces['v'].eval_base\\n if self.eval_method[0] == 'val':\\n bfref = get_val(maps, self.shape)\\n\\n elif self.eval_method[0] == 'grad':\\n bfref = get_grad(maps, self.shape)\\n\\n elif self.eval_method[0] == 'div':\\n bfref = get_grad(maps, self.shape)\\n\\n else:\\n raise NotImplementedError(\\\"The method '%s' is not implemented\\\" \\\\\\n % (self.eval_method))\\n\\n self.bfref = bfref\\n self.n_basis = self.bfref.shape[1]\",\n \"def set_rhs(self):\\n k = self.istore[:, 0]\\n ksym = self.stencil.get_symmetric()[k]\\n self.rhs[:] = self.feq[k, np.arange(k.size)] + self.feq[ksym, np.arange(k.size)]\",\n \"def set_rhs(self):\\n k = self.istore[:, 0]\\n ksym = self.stencil.get_symmetric()[k]\\n self.rhs[:] = self.feq[k, np.arange(k.size)] + self.feq[ksym, np.arange(k.size)]\",\n \"def update_forces(self):\\n\\n pass\",\n \"def updateForces(self):\\n for atom1 in range(0, self.numAtoms-1):\\n for atom2 in range(atom1+1, self.numAtoms):\\n self.calculateForce(atom1, atom2)\\n \\n # Multiply by constants \\n for atom in range(0, self.numAtoms):\\n self.atoms[atom].fx *= 48*self.e\\n self.atoms[atom].fy *= 48*self.e\\n self.atoms[atom].fz *= 48*self.e\\n self.atoms[atom].potential *= 4*self.e\",\n \"def term_1(\\n omega1, # vorticity-1\\n omega2, # vorticity-2\\n omega3, # vorticity-3\\n enst, # enstrophy\\n nu_sgs, # turbulent viscosity\\n h = True): # spatial step size\\n #---------------------------------------------------------------------#\\n # Setting default values #\\n #---------------------------------------------------------------------#\\n if h is True:\\n h = 2.0*np.pi/64.0\\n #---------------------------------------------------------------------#\\n # Preallocating space #\\n #---------------------------------------------------------------------#\\n term = np.zeros((64,64,64))\\n #---------------------------------------------------------------------#\\n # Enstrophy term #\\n #---------------------------------------------------------------------#\\n term += np.gradient(\\\\\\n np.gradient(enst, h, edge_order=2)[2], h, edge_order=2)[2]\\n term += np.gradient(\\\\\\n np.gradient(enst, h, edge_order=2)[1], h, edge_order=2)[1]\\n term += np.gradient(\\\\\\n np.gradient(enst, h, edge_order=2)[0], h, edge_order=2)[0]\\n #---------------------------------------------------------------------#\\n # Dissipation #\\n #---------------------------------------------------------------------#\\n omega1_grad = np.gradient(omega1, h, edge_order=2)\\n omega2_grad = np.gradient(omega2, h, edge_order=2)\\n omega3_grad = np.gradient(omega3, h, edge_order=2)\\n term -= np.square(omega1_grad[2])\\n term -= np.square(omega1_grad[1])\\n term -= np.square(omega1_grad[0])\\n term -= np.square(omega2_grad[2])\\n term -= np.square(omega2_grad[1])\\n term -= np.square(omega2_grad[0])\\n term -= np.square(omega3_grad[2])\\n term -= np.square(omega3_grad[1])\\n term -= np.square(omega3_grad[0])\\n #---------------------------------------------------------------------#\\n # Applying the subgrid stress #\\n #---------------------------------------------------------------------#\\n term *= nu_sgs\\n\\n return term\",\n \"def compute_bounds(self, weights, add_coeff, dual_vars, lower_bounds, upper_bounds, store_primal=False):\\n x0_coeff = -weights[0].backward(dual_vars.mus[0])\\n x0 = torch.where(x0_coeff >= 0, lower_bounds[0].unsqueeze(1), upper_bounds[0].unsqueeze(1))\\n bound = utils.bdot(x0, x0_coeff)\\n if store_primal:\\n self.bounds_primal = x0\\n else:\\n del x0\\n del x0_coeff\\n\\n for lay_idx in range(1, len(weights)):\\n lbs = lower_bounds[lay_idx].unsqueeze(1).clamp(None, 0)\\n ubs = upper_bounds[lay_idx].unsqueeze(1).clamp(0, None)\\n neg_bias = ((lbs * ubs) / (ubs - lbs))\\n neg_bias.masked_fill_(ubs == lbs, 0) # cover case in which ubs & lbs coincide\\n bound += utils.bdot(dual_vars.lambdas[lay_idx - 1].clamp(0, None), neg_bias)\\n bound -= utils.bdot(dual_vars.mus[lay_idx - 1], weights[lay_idx - 1].get_bias())\\n\\n bound += utils.bdot(add_coeff, weights[-1].get_bias())\\n return bound\",\n \"def setup_observation_term(background_data_dict,\\n obs_type_vector, obs_data_vector, obs_lat_vector, obs_lon_vector,\\n background_type_vector, background_data_vector, background_lat_vector, background_lon_vector,\\n direct_obs_operator,\\n analysis_increment_vector_symbol,\\n increment_data=0.001):\\n linearized_obs_operator = sympy.Matrix(\\n numpy.ones((len(obs_type_vector), len(background_type_vector))))\\n background_derived_obs = sympy.Matrix(\\n numpy.ones((len(obs_type_vector), 1)))\\n\\n for i_obs in range(0, len(obs_data_vector)):\\n cur_obs_type = str(obs_type_vector[i_obs])\\n cur_obs_lat = float(obs_lat_vector[i_obs])\\n cur_obs_lon = float(obs_lon_vector[i_obs])\\n\\n cur_bk_derived_obs_operator = direct_obs_operator[cur_obs_type]\\n required_bk_vars = cur_bk_derived_obs_operator.free_symbols\\n \\n # 1. calculate h(x):\\n bkg_shape = background_data_dict['lat'].shape\\n bkg_weight_0 = 0\\n bkg_weight_1 = 0\\n for ii in range(0, bkg_shape[0]):\\n for jj in range(0, bkg_shape[1]):\\n cur_bk_lat = background_data_dict['lat'][ii, jj]\\n cur_bk_lon = background_data_dict['lon'][ii, jj]\\n\\n cur_obs_operator_input = {}\\n for required_bk_var in required_bk_vars:\\n cur_obs_operator_input[str(required_bk_var)] = background_data_dict[str(required_bk_var)][ii, jj]\\n\\n cur_distance = math.sqrt((cur_obs_lat - cur_bk_lat)**2 + (cur_obs_lon - cur_bk_lon)**2)\\n cur_distance_weight_0 = (direct_obs_operator[cur_obs_type].subs(cur_obs_operator_input))/float(cur_distance**2)\\n cur_distance_weight_1 = 1.0/float(cur_distance**2)\\n bkg_weight_0 = bkg_weight_0 + cur_distance_weight_0\\n bkg_weight_1 = bkg_weight_1 + cur_distance_weight_1\\n \\n background_derived_obs[i_obs, 0] = bkg_weight_0/bkg_weight_1\\n final_bkg_weight_1 = bkg_weight_1\\n \\n # 2. find linearized observation operator\\n # n = 0\\n for i_bkg in range(0, len(background_type_vector)):\\n cur_bk_lat = float(background_lat_vector[i_bkg])\\n cur_bk_lon = float(background_lon_vector[i_bkg])\\n cur_bk_type = str(background_type_vector[i_bkg])\\n \\n cur_distance = math.sqrt((cur_obs_lat - cur_bk_lat)**2 + (cur_obs_lon - cur_bk_lon)**2)\\n cur_distance_weight_0 = cur_distance ** 2\\n distance_term = 1.0/(cur_distance_weight_0 * final_bkg_weight_1)\\n \\n l = sympy.diff(direct_obs_operator[cur_obs_type], cur_bk_type)\\n linearized_obs_operator[i_obs, i_bkg] = distance_term*l.subs(\\n {cur_bk_type: float(background_data_vector[i_bkg])})\\n \\n linearized_obs_operator_with_increments = \\\\\\n linearized_obs_operator*analysis_increment_vector_symbol\\n \\n # get the innovation:\\n innovation = obs_data_vector - background_derived_obs - \\\\\\n linearized_obs_operator_with_increments\\n return linearized_obs_operator, innovation, background_derived_obs\",\n \"def build_constraints_boundaries(self):\\n\\n # Trapezoidal and Hermite-Simpson methods can't compute\\n # defects at the last node contrary to pseudospectral methods\\n coll_method = self.options['tr_method'] in [\\n 'trapezoidal', 'hermite-simpson']\\n n_nodes = self.problem.prm['n_nodes'] - \\\\\\n 1 if coll_method else self.problem.prm['n_nodes']\\n\\n # Defects lower and upper boundaries\\n defects_low = np.zeros(\\n self.problem.prm['n_states'] * n_nodes)\\n defects_upp = np.zeros(\\n self.problem.prm['n_states'] * n_nodes)\\n\\n # Path lower and upper boundaries\\n path_low = np.hstack([self.problem.low_bnd.path]\\n * (self.problem.prm['n_nodes']))\\n path_upp = np.hstack([self.problem.upp_bnd.path]\\n * (self.problem.prm['n_nodes']))\\n\\n # Events lower and upper boundaries\\n event_low = self.problem.low_bnd.event\\n event_upp = self.problem.upp_bnd.event\\n\\n # Assembly of the lower and upper boundaries vectors\\n low = np.concatenate((defects_low, path_low, event_low))\\n upp = np.concatenate((defects_upp, path_upp, event_upp))\\n\\n return low, upp\",\n \"def boundary_conditions(self):\\n pass\",\n \"def relax(self):\\n # print(\\\"putin\\\", self.level.rhs.reshape(-1)[:])\\n # print(\\\"getout\\\", self.solver(self.level.rhs.reshape(-1)))\\n\\n self.level.mid[:] = self.solver(self.level.rhs.reshape(-1)).reshape(self.level.mid.shape)\",\n \"def update_forces(self):\\n element: Cell\\n element1: Cell\\n element2: Cell\\n for element in self.cells:\\n element.force = Vector(.0, .0, .0)\\n\\n tmp_systems = self.cells.copy()\\n to_delete = set()\\n for element1 in self.cells:\\n for element2 in self.cells:\\n if element1 == element2:\\n continue\\n if element2.distance(element1) <= element2.r_max:\\n force = find_force(element1, element2)\\n element1.force += force\\n element2.force += -force\\n to_delete.add(element2)\\n tmp_systems -= to_delete\\n to_delete.clear()\",\n \"def applyForce(self, F, dT):\",\n \"def add_cp_le_RBM_terms_alt(K, cons_pot_mesh, lin_geo_mesh):\\n num_faces = cons_pot_mesh.get_faces().shape[0]\\n x_c = lin_geo_mesh.get_centroid()\\n w = lin_geo_mesh.get_w()\\n A_m = lin_geo_mesh.get_A_m()\\n S_D = lin_geo_mesh.get_surface_area()\\n\\n for face_num in range(num_faces):\\n face_nodes = lin_geo_mesh.get_tri_nodes(face_num)\\n face_hs = lin_geo_mesh.get_hs(face_num)\\n face_center = lin_geo_mesh.get_tri_center(face_num)\\n v_sub_mat = (1. / S_D) * (np.identity(3) * 0.5 * face_hs) # simple integral\\n tmp_omega = []\\n for m in range(3):\\n def make_omega_quad(w, A_m):\\n def omega_quad(xi, eta, nodes):\\n pos = geo.linear_interp(xi, eta, nodes)\\n X = pos - x_c\\n return np.cross(w, X)\\n return omega_quad\\n tmp_omega.append(gq.int_over_tri_lin(\\n make_omega_quad(w[m], A_m[m]),\\n face_nodes,\\n face_hs,\\n ))\\n for src_num in range(num_faces):\\n K[(3 * src_num):(3 * src_num + 3),\\n (3 * face_num):(3 * face_num + 3)] += v_sub_mat\\n src_center = cons_pot_mesh.get_node(src_num)\\n X_0 = src_center - x_c\\n tmp_arr = []\\n for m in range(3):\\n tmp_arr.append(np.outer((1./ A_m[m]) * np.cross(w[m], X_0), tmp_omega[m]))\\n tmp_arr = np.array(tmp_arr)\\n omega_mat = np.sum(tmp_arr, axis=0)\\n K[(3 * src_num):(3 * src_num + 3),\\n (3 * face_num):(3 * face_num + 3)] += omega_mat\",\n \"def do_relax(self):\\n raise NotImplementedError\",\n \"def regularize_if_necessary(self) -> None:\\n # As described in [wang2014], all entities and relations are used to compute the regularization term\\n # which enforces the defined soft constraints.\\n super().regularize_if_necessary(\\n self.entity_embeddings.weight,\\n self.normal_vector_embeddings.weight,\\n self.relation_embeddings.weight,\\n )\",\n \"def test_update_boundary_opt(self):\\n self.set_up()\\n boundary_opt_new = np.hstack((self.vmecOptimization.boundary_opt,\\n self.vmecOptimization.boundary_opt))\\n self.assertRaises(ValueError,self.vmecOptimization.update_boundary_opt,\\n boundary_opt_new)\\n boundary_opt_new = np.copy(self.vmecOptimization.boundary_opt)\\n boundary_opt_new[0] = 1\\n self.vmecOptimization.update_boundary_opt(boundary_opt_new)\\n self.assertEqual(1,self.vmecOptimization.boundary_opt[0])\\n self.tear_down()\",\n \"def calculate_thickness_terms(self):\\n\\n self.calculate_min_thickness()\\n self._calculate_driven_mass()\\n self._calculate_resonant_frequency()\\n self._calculate_quilting_error()\",\n \"def incumbent(self):\\n return self.boundary_handler.repair(self.mean)\",\n \"def _set_bounds(b, x, n):\\n for j in range(1, n - 1):\\n for i in range(1, n - 1):\\n x[index_of(i, j, 0, n)] = -x[index_of(i, j, 1, n)] if b == 3 else x[index_of(i, j, 1, n)]\\n x[index_of(i, j, 0, n - 1)] = -x[index_of(i, j, 1, n - 2)] if b == 3 else x[index_of(i, j, 1, n - 2)]\\n for k in range(1, n - 1):\\n for i in range(1, n - 1):\\n x[index_of(i, 0, k, n)] = -x[index_of(i, 1, k, n)] if b == 2 else x[index_of(i, 1, k, n)]\\n x[index_of(i, n - 1, 0, n - 1)] = -x[index_of(i, n - 2, k, n - 2)] if b == 2 else x[\\n index_of(i, n - 2, k, n - 2)]\\n for k in range(1, n - 1):\\n for j in range(1, n - 1):\\n x[index_of(0, j, k, n)] = -x[index_of(1, j, k, n)] if b == 1 else x[index_of(1, j, k, n)]\\n x[index_of(n - 1, j, k, n - 1)] = -x[index_of(n - 2, j, k, n)] if b == 1 else x[\\n index_of(n - 2, j, k, n)]\\n\\n x[index_of(0, 0, 0, n)] = 1 / 3 * (x[index_of(1, 0, 0, n)] + x[index_of(0, 1, 0, n)] + x[index_of(0, 0, 1, n)])\\n x[index_of(0, n - 1, 0, n)] = 1 / 3 * (\\n x[index_of(1, n - 1, 0, n)] + x[index_of(0, n - 2, 0, n)] + x[index_of(0, n - 1, 1, n)])\\n x[index_of(0, 0, n - 1, n)] = 1 / 3 * (\\n x[index_of(1, 0, n - 1, n)] + x[index_of(0, 1, n - 1, n)] + x[index_of(0, 0, n - 2, n)])\\n x[index_of(0, n - 1, n - 1, n)] = 1 / 3 * (\\n x[index_of(1, n - 1, n - 1, n)] + x[index_of(0, n - 2, n - 1, n)] + x[index_of(0, n - 1, n - 2, n)])\\n x[index_of(n - 1, 0, 0, n)] = 1 / 3 * (\\n x[index_of(n - 2, 0, 0, n)] + x[index_of(n - 1, 1, 0, n)] + x[index_of(n - 1, 0, 1, n)])\\n x[index_of(n - 1, n - 1, 0, n)] = 1 / 3 * (\\n x[index_of(n - 2, n - 1, 0, n)] + x[index_of(n - 1, n - 2, 0, n)] + x[index_of(n - 1, n - 1, 1, n)])\\n x[index_of(n - 1, 0, n - 1, n)] = 1 / 3 * (\\n x[index_of(n - 2, 0, n - 1, n)] + x[index_of(n - 1, 1, n - 1, n)] + x[index_of(n - 1, 0, n - 2, n)])\\n x[index_of(n - 1, n - 1, n - 1, n)] = 1 / 3 * (\\n x[index_of(n - 2, n - 1, n - 1, n)] + x[index_of(n - 1, n - 2, n - 1, n)] + x[\\n index_of(n - 1, n - 1, n - 2, n)])\",\n \"def set_initial_condition(self):\\n X0 = np.array([0.5, 0.5])\\n XB = self.bary\\n q0 = 1 + np.exp(-0.5*(np.sum((XB-X0[np.newaxis])**2., axis=1))/0.1**2)\\n q1 = np.zeros(q0.shape)\\n #import pdb; pdb.set_trace()\\n return np.array([q0, q1, q1]).T\",\n \"def set_boundary(self, t):\\n gw_level = self.gwhead[t]\\n if np.isfinite(gw_level):\\n self.gw.potential = gw_level\",\n \"def __get_new_restriction_branch_and_bound(self, tableau, var_col, b_value):\\n restriction_row = np.zeros((tableau.get_tableau_num_cols())).astype('object')\\n restriction_row[var_col] = 1\\n restriction_row[tableau.get_tableau_num_cols() - 1] = b_value\\n\\n for i in xrange(0, len(restriction_row)):\\n restriction_row[i] = Fraction(restriction_row[i])\\n\\n return restriction_row\",\n \"def compute_ghost_series(self,terms):\\n\\t\\tp=self.p\\n\\t\\tcomp=self.comp\\n\\t\\tf1=self.f1\\n\\t\\tf2=self.f2\\n\\n\\t\\tghost_coefs = [[] for i in range(terms+1)]\\n\\n\\n\\t\\tk=comp;\\n\\t\\tif k==0 or k==1:\\n\\t\\t\\tk=k+p-1\\n\\n\\t\\t## Precompute the needed dimensions\\n\\t\\tself.f1v = [f1(k)]\\n\\t\\tself.f2v = [f2(k)]\\n\\t\\tk = k + p-1\\n\\t\\twhile self.f1v[len(self.f1v)-1] <= terms+1:\\n\\t\\t\\tself.f1v += [f1(k)]\\n\\t\\t\\tself.f2v += [f2(k)]\\n\\t\\t\\tk = k + p-1\\n\\t\\t\\n\\t\\t## Starting at weight 2, we run through weights in the component,\\n\\t\\t## compute the associated indices, and then record the weights at those\\n\\t\\t## indices with appropriate multiplicities\\n\\n\\t\\tk = comp;\\n\\t\\tif k==0 or k==1:\\n\\t\\t\\tk=k+p-1\\n\\t\\tn = 0\\n\\n\\t\\tinds = range(self.f1v[n]+1,self.f1v[n]+self.f2v[n])\\n\\t\\twhile (len(inds)==0 or inds[0]<=terms+1):\\n\\t\\t\\t## This loops adds the weights to the appropriate indices with the appropriate multiplicities\\n\\t\\t\\tfor m in range(floor((len(inds)+1)/2)):\\n\\t\\t\\t\\tif m < floor(len(inds)/2):\\n\\t\\t\\t\\t\\tif inds[m]<=terms:\\n\\t\\t\\t\\t\\t\\tghost_coefs[inds[m]] += [(k,m+1)]\\n\\t\\t\\t\\t\\tif (inds[len(inds)-1-m]<=terms):\\n\\t\\t\\t\\t\\t\\tghost_coefs[inds[len(inds)-1-m]] += [(k,m+1)]\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tif inds[m]<=terms:\\n\\t\\t\\t\\t\\t\\tghost_coefs[inds[m]] += [(k,m+1)]\\n\\t\\t\\tk = k + p-1\\n\\t\\t\\tn = n + 1\\n\\t\\t\\tinds = range(self.f1v[n]+1,self.f1v[n]+self.f2v[n])\\n\\t\\tself.series=ghost_coefs\",\n \"def normalize_all(self):\\n #for i, vector in enumerate(self.real_vectors):\\n # self.real_vectors[i] /= np.linalg.norm(vector)\\n self.vectors /= np.linalg.norm(self.vectors, axis=1).reshape(-1,1)\\n for i, vector in enumerate(self.real_vectors):\\n vector.set(self.vectors[i])\",\n \"def additional_equations(self, k):\\n ######################################################################\\n # equation for saturated liquid at hot side outlet\\n if self.subcooling.val is False:\\n o1 = self.outl[0].to_flow()\\n self.residual[k] = o1[2] - h_mix_pQ(o1, 0)\\n k += 1\",\n \"def SetPRBinCatConstraint( self, model ) :\\n tot = np.dot( self.wish.T, self.dispo )\\n for val in tot :\\n if not val : continue\\n if self.bound>0 : model += val <= self.valBound\\n elif self.bound<0 : model += val >= self.valBound\",\n \"def update(self):\\n self._g, self._B = self._constraint_assembler.preallocate_g_and_B(self._no_of_dofs_unconstrained,\\n self._dofidxs(),\\n self._no_of_constraints_by_object())\",\n \"def set_freq_relaxation(self):\\n self.num_omega=5\\n self.omega=np.zeros(self.num_omega)\\n iOmH = 3 ; # indexing for the frequencies.\\n iOmX = 1 ; #\\n # First determine the frequencies omega and J from given inputs.\\n self.omega[iOmH] = -1.0*self.gH.gamma*self.B_0*self.time_fact\\n self.omega[iOmX] = -1.0*self.gX.gamma*self.B_0*self.time_fact\\n self.omega[iOmH-iOmX] = (self.omega[iOmH]-self.omega[iOmX])\\n self.omega[iOmH+iOmX] = (self.omega[iOmH]+self.omega[iOmX])\",\n \"def _merge_boundaries(self):\\n optical = self._amalgamated_optical\\n if bool(optical):\\n optical[\\\"catagory\\\"] = OPTICAL * tf.ones_like(\\n optical[\\\"xp\\\"],\\n dtype=tf.int64\\n )\\n self._optical_count = tf.shape(\\n optical[\\\"xp\\\"],\\n out_type=tf.int64\\n )[0]\\n else:\\n self._optical_count = 0\\n \\n stop = self._amalgamated_stop\\n if bool(stop):\\n stop[\\\"catagory\\\"] = STOP * tf.ones_like(\\n stop[\\\"xp\\\"],\\n dtype=tf.int64\\n )\\n self._stop_count = tf.shape(\\n stop[\\\"xp\\\"],\\n out_type=tf.int64\\n )[0]\\n else:\\n self._stop_count = 0\\n \\n target = self._amalgamated_target\\n if bool(target):\\n target[\\\"catagory\\\"] = TARGET * tf.ones_like(\\n target[\\\"xp\\\"],\\n dtype=tf.int64\\n )\\n self._target_count = tf.shape(\\n target[\\\"xp\\\"],\\n out_type=tf.int64\\n )[0]\\n else:\\n self._target_count = 0\\n \\n self._merged = amalgamate(\\n [optical, stop, target], \\n TRIANGLE_GEO_SIG | {\\\"catagory\\\"}\\n )\",\n \"def boundary(self):\\n\\n answer = self.zero()\\n if self.torsion == 2:\\n for k in self.keys():\\n for idx in range(0, len(k)):\\n bdry_summand = k[:idx] + k[idx + 1:]\\n if k[idx] in bdry_summand:\\n answer += self.create({bdry_summand: 1})\\n return answer\\n if self.convention == 'Berger-Fresse':\\n for k, v in self.items():\\n # determining the signs of the summands\\n signs = {}\\n alternating_sign = 1\\n for idx, i in enumerate(k):\\n if i in k[idx + 1:]:\\n signs[idx] = alternating_sign\\n alternating_sign *= (-1)\\n elif i in k[:idx]:\\n occurs = (pos for pos, j in enumerate(k[:idx]) if i == j)\\n signs[idx] = signs[max(occurs)] * (-1)\\n else:\\n signs[idx] = 0\\n # computing the summands\\n for idx in range(0, len(k)):\\n bdry_summand = k[:idx] + k[idx + 1:]\\n if k[idx] in bdry_summand:\\n answer += self.create({bdry_summand: signs[idx] * v})\\n if self.convention == 'McClure-Smith':\\n for k, v in self.items():\\n sign = 1\\n for i in range(1, max(k) + 1):\\n for idx in (idx for idx, j in enumerate(k) if j == i):\\n new_k = k[:idx] + k[idx + 1:]\\n if k[idx] in new_k:\\n answer += answer.create({new_k: v * sign})\\n sign *= -1\\n sign *= -1\\n return answer\",\n \"def equalize(pair, bias_axis, word_to_vec_map):\\n\\n ### START CODE HERE ###\\n # Step 1: Select word vector representation of \\\"word\\\". Use word_to_vec_map. (≈ 2 lines)\\n w1, w2 = pair\\n e_w1, e_w2 = (word_to_vec_map[w1], word_to_vec_map[w2])\\n\\n # Step 2: Compute the mean of e_w1 and e_w2 (≈ 1 line)\\n mu = (e_w1 + e_w2) / 2\\n\\n # Step 3: Compute the projections of mu over the bias axis and the orthogonal axis (≈ 2 lines)\\n mu_B = np.dot(mu, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\\n mu_orth = mu - mu_B\\n\\n # Step 4: Use equations (7) and (8) to compute e_w1B and e_w2B (≈2 lines)\\n e_w1B = np.dot(e_w1, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\\n e_w2B = np.dot(e_w2, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\\n\\n # Step 5: Adjust the Bias part of e_w1B and e_w2B using the formulas (9) and (10) given above (≈2 lines)\\n corrected_e_w1B = np.sqrt(np.abs(1 - np.sum(np.dot(mu_orth, mu_orth)))) * (e_w1B - mu_B) / np.sqrt(\\n np.sum(np.dot(e_w1 - mu_orth - mu_B, e_w1 - mu_orth - mu_B)))\\n corrected_e_w2B = np.sqrt(np.abs(1 - np.sum(np.dot(mu_orth, mu_orth)))) * (e_w2B - mu_B) / np.sqrt(\\n np.sum(np.dot(e_w2 - mu_orth - mu_B, e_w2 - mu_orth - mu_B)))\\n\\n # Step 6: Debias by equalizing e1 and e2 to the sum of their corrected projections (≈2 lines)\\n e1 = corrected_e_w1B + mu_orth\\n e2 = corrected_e_w2B + mu_orth\\n\\n ### END CODE HERE ###\\n\\n return e1, e2\",\n \"def calculateRightHandSide(self):\\n\\n #each element triangulation.simplices is a list with the point indices of the triangle\\n for ele,triPoints in enumerate(self.triangulation.simplices):\\n elementRHS = self.calculateElementRightHandSide(ele)\\n\\n for index,entry in enumerate(elementRHS):\\n self.rightHandSide[triPoints[index]] += entry\\n\\n #overwrite the values at the prescribed boundaries condition\\n for indexValue in self.prescribedValues:\\n self.rightHandSide[int(indexValue[0])] = indexValue[1]\\n #print(self.rightHandSide)\",\n \"def add_cp_le_RBM_terms(K, cons_pot_mesh, lin_geo_mesh):\\n num_faces = cons_pot_mesh.get_faces().shape[0]\\n x_c = lin_geo_mesh.get_centroid()\\n w = lin_geo_mesh.get_w()\\n A_m = lin_geo_mesh.get_A_m()\\n S_D = lin_geo_mesh.get_surface_area()\\n\\n for face_num in range(num_faces):\\n face_nodes = lin_geo_mesh.get_tri_nodes(face_num)\\n face_hs = lin_geo_mesh.get_hs(face_num)\\n v_sub_mat = (1. / S_D) * (np.identity(3) * 0.5 * face_hs) # simple integral\\n def omega_quad(xi, eta, nodes):\\n pos = geo.linear_interp(xi, eta, nodes)\\n X = pos - x_c\\n return np.einsum(\\\"lrs,s->lr\\\", geo.LC_3, X)\\n tmp_omega = gq.int_over_tri_lin(\\n omega_quad,\\n face_nodes,\\n face_hs,\\n )\\n tmp_arr = []\\n for m in range(3):\\n tmp_arr.append((1./ A_m[m]) * np.outer(w[m], np.einsum(\\\"l,ls\\\", w[m], tmp_omega)))\\n tmp_arr = np.array(tmp_arr)\\n tmp_omega_mat = np.sum(tmp_arr, axis=0)\\n for src_num in range(num_faces):\\n K[(3 * src_num):(3 * src_num + 3),\\n (3 * face_num):(3 * face_num + 3)] += v_sub_mat\\n #src_center = cons_pot_mesh.get_node(src_num)\\n src_center = lin_geo_mesh.get_tri_center(src_num)\\n X_0 = src_center - x_c\\n omega_mat = np.einsum(\\\"ijk,js,k->is\\\", geo.LC_3, tmp_omega_mat, X_0)\\n K[(3 * src_num):(3 * src_num + 3),\\n (3 * face_num):(3 * face_num + 3)] += omega_mat\",\n \"def set_bc(self, problem):\\n bcs = problem.bcs\\n n_bound = cfg.const['N_GHOST_CELLS']\\n # Left X-b.c.\\n for i in range(0, self.i_min):\\n for j in range(self.j_min, self.j_max):\\n for k in range(self.k_min, self.k_max): \\n if bcs[0] == 't': \\n self.U[i][j][k] = self.U[self.i_min][j][k]\\n elif bcs[0] == 'w':\\n for num in [0, 2, 3, 4]: # 0 -> 3, 1 -> 2, i_min-1 -> i_min, i_min-2 -> i_min+1\\n self.U[i][j][k][num] = self.U[self.i_min + (self.i_min - i - 1)][j][k][num]\\n for num in [1]:\\n self.U[i][j][k][num] = - self.U[self.i_min + (self.i_min - i - 1)][j][k][num]\\n else:\\n print(\\\"Errof field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\\n # Right X-b.c.\\n for i in range(self.i_max, self.i_max+n_bound):\\n for j in range(self.j_min, self.j_max):\\n for k in range(self.k_min, self.k_max): \\n if bcs[1] == 't':\\n self.U[i][j][k] = self.U[self.i_max-1][j][k]\\n elif bcs[1] == 'w':\\n for num in [0, 2, 3, 4]: # i_max -> i_max-1 , i_max+1-> i_max-2\\n self.U[i][j][k][num] = self.U[self.i_max - (i - self.i_max + 1)][j][k][num]\\n for num in [1]:\\n self.U[i][j][k][num] = - self.U[self.i_max - (i - self.i_max + 1)][j][k][num]\\n else:\\n print(\\\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\\n # Left Y-b.c.\\n for i in range(0, self.i_max+n_bound):\\n for j in range(0, self.j_min):\\n for k in range(self.k_min, self.k_max): \\n if bcs[2] == 't':\\n self.U[i][j][k] = self.U[i][self.j_min][k]\\n elif bcs[2] == 'w':\\n for num in [0, 1, 3, 4]:\\n self.U[i][j][k][num] = self.U[i][self.j_min + (self.j_min - j - 1)][k][num]\\n for num in [2]:\\n self.U[i][j][k][num] = - self.U[i][self.j_min + (self.j_min - j - 1)][k][num]\\n else:\\n print(\\\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\\n # Right Y-b.c.\\n for i in range(0, self.i_max+n_bound):\\n for j in range(self.j_max, self.j_max+n_bound):\\n for k in range(self.k_min, self.k_max): \\n if bcs[3] == 't':\\n self.U[i][j][k] = self.U[i][self.j_max-1][k]\\n elif bcs[3] == 'w':\\n for num in [0, 1, 3, 4]:\\n self.U[i][j][k][num] = self.U[i][self.j_max - (j - self.j_max + 1)][k][num]\\n for num in [2]:\\n self.U[i][j][k][num] = -self.U[i][self.j_max - (j - self.j_max + 1)][k][num]\\n else:\\n print(\\\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\\n # Left Z-b.c.\\n for i in range(0, self.i_max+n_bound):\\n for j in range(0, self.j_max+n_bound):\\n for k in range(0, self.k_min): \\n if bcs[4] == 't':\\n self.U[i][j][k] = self.U[i][j][self.k_min]\\n elif bcs[4] == 'w':\\n for num in [0, 1, 2, 4]:\\n self.U[i][j][k][num] = self.U[i][j][self.k_min + (self.k_min - k - 1)][num]\\n for num in [3]:\\n self.U[i][j][k][num] = - self.U[i][j][self.k_min + (self.k_min - k - 1)][num]\\n else:\\n print(\\\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\\n # Right Z-b.c.\\n for i in range(0, self.i_max+n_bound):\\n for j in range(0, self.j_max+n_bound):\\n for k in range(self.k_max, self.k_max+n_bound):\\n if bcs[5] == 't':\\n self.U[i][j][k] = self.U[i][j][self.k_max-1]\\n elif bcs[5] == 'w':\\n for num in [0, 1, 2, 4]:\\n self.U[i][j][k][num] = self.U[i][j][self.k_max - (k - self.k_max + 1)][num]\\n for num in [3]:\\n self.U[i][j][k][num] = - self.U[i][j][self.k_max - (k - self.k_max + 1)][num]\\n else:\\n print(\\\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\",\n \"def ComputeBasis(self, p_float=..., p_float=..., p_float=..., *args, **kwargs):\\n ...\",\n \"def set_bounds_atom(self,bounds):\\n assert bounds.shape == (2,self.Phi.d)\\n self.bounds = bounds # data bounds\\n self.bounds_atom = bounds.T.tolist()\\n for i in range(self.Phi.d): # bounds for the variance in each dimension\\n max_variance_this_dimension = (bounds[1][i]-bounds[0][i])**2\\n self.bounds_atom.append([self.variance_relative_lowerbound*max_variance_this_dimension,\\n self.variance_relative_upperbound*max_variance_this_dimension])\",\n \"def real_reduce(self, bound, large_constant):\\n approximation_matrix = self.generate_approximation_matrix(large_constant)\\n LLL_matrix = self.generate_LLL_matrix(approximation_matrix)\\n GS_matrix = self.generate_GS_matrix(LLL_matrix) \\n minimal_vector_bound = self.calculate_minimal_vector_bound(large_constant, LLL_matrix, GS_matrix)\\n S, T = self.calculate_S_and_T(self.coefficients[\\\"Z_bounds\\\"])\\n print('ST',T**2 + S)\\n new_bound = self.real_reduce_new_bound(large_constant, minimal_vector_bound, S, T)\\n print('diff_bound',new_bound)\\n return new_bound\",\n \"def additional_equations(self, k):\\n ######################################################################\\n # equation for saturated gas at hot side outlet\\n o1 = self.outl[0].to_flow()\\n self.residual[k] = o1[2] - h_mix_pQ(o1, 1)\",\n \"def test_handling_of_variable_bound_sums_in_merge(free_alg):\\n\\n dr = free_alg\\n p = dr.names\\n\\n x = IndexedBase('x')\\n v = p.v\\n i = p.i\\n r = p.R\\n\\n first = dr.sum((i, r), x[i] * v[i])\\n\\n # First trial, when the ranges are really the same.\\n assert dr.simplify(\\n first - dr.sum((i, r), x[i] * v[i])\\n ) == 0\\n\\n # This time, they should not be merged.\\n assert dr.simplify(\\n first - dr.sum((i, r[0, Symbol('n')]), x[i] * v[i])\\n ).n_terms == 2\",\n \"def compute_bound(self, sstats, totals):\\n w = self.vocab_len\\n t = self.num_time_slices\\n\\n term_1 = 0\\n term_2 = 0\\n term_3 = 0\\n\\n val = 0\\n ent = 0\\n\\n chain_variance = self.chain_variance\\n # computing mean, fwd_mean\\n self.mean, self.fwd_mean = \\\\\\n (np.array(x) for x in zip(*(self.compute_post_mean(w, self.chain_variance) for w in range(w))))\\n self.zeta = self.update_zeta()\\n\\n val = sum(self.variance[w][0] - self.variance[w][t] for w in range(w)) / 2 * chain_variance\\n\\n logger.info(\\\"Computing bound, all times\\\")\\n\\n for t in range(1, t + 1):\\n term_1 = 0.0\\n term_2 = 0.0\\n ent = 0.0\\n for w in range(w):\\n\\n m = self.mean[w][t]\\n prev_m = self.mean[w][t - 1]\\n\\n v = self.variance[w][t]\\n\\n # w_phi_l is only used in Document Influence Model; the values are always zero in this case\\n # w_phi_l = sslm.w_phi_l[w][t - 1]\\n # exp_i = np.exp(-prev_m)\\n # term_1 += (np.power(m - prev_m - (w_phi_l * exp_i), 2) / (2 * chain_variance)) -\\n # (v / chain_variance) - np.log(chain_variance)\\n\\n term_1 += \\\\\\n (np.power(m - prev_m, 2) / (2 * chain_variance)) - (v / chain_variance) - np.log(chain_variance)\\n term_2 += sstats[w][t - 1] * m\\n ent += np.log(v) / 2 # note the 2pi's cancel with term1 (see doc)\\n\\n term_3 = -totals[t - 1] * np.log(self.zeta[t - 1])\\n val += term_2 + term_3 + ent - term_1\\n\\n return val\",\n \"def _construct_compute_fe_terms(self):\\n # setup some symbolic variables for theano to deal with\\n xi = T.matrix()\\n xo = T.matrix()\\n _, hi_zmuv = self._construct_zmuv_samples(xi, 1)\\n # construct values to output\\n nll = self.nlli[-1]\\n kld = self.kld_z.flatten() + self.kld_hi_q2p.flatten()\\n # compile theano function for a one-sample free-energy estimate\\n fe_term_sample = theano.function(inputs=[ xi, xo ], \\\\\\n outputs=[nll, kld], \\\\\\n givens={self.x_in: xi, \\\\\\n self.x_out: xo, \\\\\\n self.hi_zmuv: hi_zmuv}, \\\\\\n updates=self.scan_updates)\\n # construct a wrapper function for multi-sample free-energy estimate\\n def fe_term_estimator(XI, XO, sample_count):\\n # compute a multi-sample estimate of variational free-energy\\n nll_sum = np.zeros((XI.shape[0],))\\n kld_sum = np.zeros((XI.shape[0],))\\n for i in range(sample_count):\\n result = fe_term_sample(XI, XO)\\n nll_sum += result[0].ravel()\\n kld_sum += result[1].ravel()\\n mean_nll = nll_sum / float(sample_count)\\n mean_kld = kld_sum / float(sample_count)\\n return [mean_nll, mean_kld]\\n return fe_term_estimator\",\n \"def removeFixedEffect(self, index=None):\\n if self._n_terms==0:\\n pass\\n if index is None or index==(self._n_terms-1):\\n\\n self._n_terms-=1\\n F = self._F.pop() #= self.F[:-1]\\n A = self._A.pop() #= self.A[:-1]\\n self._A_identity.pop() #= self.A_identity[:-1]\\n REML_term = self._REML_term.pop()# = self.REML_term[:-1]\\n self._B.pop()# = self.B[:-1]\\n self._n_fixed_effs-=F.shape[1]*A.shape[0]\\n if REML_term:\\n self._n_fixed_effs_REML-=F.shape[1]*A.shape[0]\\n\\n pass\\n elif index >= self.n_terms:\\n raise Exception(\\\"index exceeds max index of terms\\\")\\n else:\\n raise NotImplementedError(\\\"currently only last term can be removed\\\")\\n pass\\n self._rebuild_indicator()\\n self.clear_cache('Fstar','Astar','Xstar','Xhat',\\n 'Areml','Areml_eigh','Areml_chol','Areml_inv','beta_hat','B_hat',\\n 'LRLdiag_Xhat_tens','Areml_grad',\\n 'beta_grad','Xstar_beta_grad','Zstar','DLZ')\",\n \"def addObjFxnTerm(model, A, x, b, wt, n_aux, name, lb=0):\\n import gurobipy as gb\\n Ax = model.addMVar(n_aux, vtype=gb.GRB.CONTINUOUS, lb=lb, name=name)\\n model.addConstr(A @ x == Ax, name=f\\\"{name}_cons\\\") # Constrain the Ax auxiliary variable to be equal to query answer\\n #return wt * (Ax @ Ax - 2 * b @ Ax) # Quadratic obj_fxn terms for query answers: wt * (Ax - b)^2, constant dropped\\n return (Ax @ wt @ Ax - 2 * b @ wt @ Ax) # Quadratic obj_fxn terms for query answers: wt * (Ax - b)^2, constant dropped\",\n \"def buildWPriorTerm(self):\\r\\n\\r\\n # self.w_prior.shape == (minibatch size,)\\r\\n self.w_prior = 0.5*T.sum(1 + T.log(self.qwgy_var) - self.qwgy_mu**2-self.qwgy_var, axis=1)\\r\\n\\r\\n self.w_prior_modif = - T.maximum(self.hyper['treshold_w_prior'], -self.w_prior)\",\n \"def reset_hessian_and_bias(self):\\n # reset_shared_var(self.t_H)\\n t = self.QUAD_REG\\n if len(t.shape) == 1:\\n self.t_H.set_value(np.diag(self.QUAD_REG))\\n elif len(t.shape) == 2:\\n self.t_H.set_value(self.QUAD_REG)\\n else:\\n raise ValueError('Invalid quad_reg shape')\\n\\n reset_shared_var(self.t_B)\",\n \"def _initialize_bounds(problem, bounds, get_bound, set_bound):\\n for constraint in problem.constraints:\\n root_expr = constraint.root_expr\\n expr_bounds = Interval(constraint.lower_bound, constraint.upper_bound)\\n if root_expr not in bounds:\\n set_bound(root_expr, expr_bounds)\\n else:\\n existing_bounds = get_bound(root_expr)\\n new_bounds = existing_bounds.intersect(expr_bounds)\\n set_bound(root_expr, new_bounds)\",\n \"def forces(self):\\n pass\",\n \"def epflux_eddyterms():\\n pass\",\n \"def preprocess(self):\\n\\n if self.x_range == None:\\n x_min = min(np.min(self.fx), np.min(self.gx))\\n x_max = max(np.max(self.fx), np.max(self.gx))\\n self.x_range = [x_min,x_max]\\n\\n f_inter = interpolate.interp1d(self.fx, self.fy, 'cubic', fill_value = 'extrapolate')\\n g_inter = interpolate.interp1d(self.gx, self.gy, 'cubic', fill_value = 'extrapolate')\\n fgx_new = np.linspace(self.x_range[0], self.x_range[1], self.N)\\n fy_new = f_inter(fgx_new)\\n gy_new = g_inter(fgx_new)\\n\\n self.fx, self.fy = fgx_new, fy_new\\n self.gx, self.gy = fgx_new, gy_new\",\n \"def calc(self):\\n\\n # the following if query ensures that volume- and interaction-terms\\n # are only calculated if tau > 0.\\n # (to avoid nan-values from invalid function-evaluations)\\n\\n if self.V.tau.shape == (1,):\\n Isurf = self.surface()\\n # differentiation for non-existing canopy, as otherwise NAN values\\n if self.V.tau > 0.:\\n Ivol = self.volume()\\n if self.int_Q is True:\\n Iint = self.interaction()\\n else:\\n Iint = np.array([0.])\\n else:\\n Ivol = np.array([0.])\\n Iint = np.array([0.])\\n else:\\n # calculate surface-term (valid for any tau-value)\\n Isurf = self.surface()\\n\\n # store initial parameter-values\\n old_t_0 = self.t_0\\n old_p_0 = self.p_0\\n old_t_ex = self.t_ex\\n old_p_ex = self.p_ex\\n\\n old_tau = self.V._get_tau()\\n old_omega = self.V._get_omega()\\n old_NN = self.SRF._get_NormBRDF()\\n\\n # set mask for tau > 0.\\n mask = old_tau > 0.\\n valid_index = np.where(mask)\\n inval_index = np.where(~mask)\\n\\n # set parameter-values to valid values for calculation\\n self.t_0 = old_t_0[valid_index[0]]\\n self.p_0 = old_p_0[valid_index[0]]\\n self.t_ex = old_t_ex[valid_index[0]]\\n self.p_ex = old_p_ex[valid_index[0]]\\n\\n # squeezing the arrays is necessary since the setter-function for\\n # tau, omega and NormBRDF automatically adds an axis to the arrays!\\n self.V.tau = np.squeeze(old_tau[valid_index[0]])\\n if np.array(self.V.omega).size != 1:\\n self.V.omega = np.squeeze(old_omega[valid_index[0]])\\n if np.array(self.SRF.NormBRDF).size != 1:\\n self.SRF.NormBRDF = np.squeeze(old_NN[valid_index[0]])\\n\\n # calculate volume and interaction term where tau-values are valid\\n _Ivol = self.volume()\\n if self.int_Q is True:\\n _Iint = self.interaction()\\n else:\\n _Iint = np.full_like(self.t_0, 0.)\\n\\n # reset parameter values to old values\\n self.t_0 = old_t_0\\n self.p_0 = old_p_0\\n self.t_ex = old_t_ex\\n self.p_ex = old_p_ex\\n\\n # squeezing the arrays is necessary since the setter-function for\\n # tau, omega and NormBRDF automatically add an axis to the arrays!\\n self.V.tau = np.squeeze(old_tau)\\n self.V.omega = np.squeeze(old_omega)\\n self.SRF.NormBRDF = np.squeeze(old_NN)\\n\\n # combine calculated volume-contributions for valid tau-values\\n # with zero-arrays for invalid tau-values\\n Ivol = np.ones_like(self.t_0)\\n Ivol[valid_index[0]] = _Ivol\\n Ivol[inval_index[0]] = np.ones_like(Ivol[inval_index[0]]) * 0.\\n\\n # combine calculated interaction-contributions for valid tau-values\\n # with zero-arrays for invalid tau-values\\n if self.int_Q is True:\\n Iint = np.ones_like(self.t_0)\\n Iint[valid_index[0]] = _Iint\\n Iint[inval_index[0]] = np.ones_like(Iint[inval_index[0]]) * 0.\\n else:\\n Iint = np.full_like(self.t_0, 0.)\\n\\n return Isurf + Ivol + Iint, Isurf, Ivol, Iint\",\n \"def _redef_sp1_vars(self):\\r\\n\\r\\n if len(self.fq_list) == 0:\\r\\n no_rad = True\\r\\n lst_tmp = np.matrix(np.reshape(self.lst_tmp, \\r\\n (self.lst_tmp.size, 1)))\\r\\n else: no_rad = False\\r\\n # The practically constants...\\r\\n # Big Epsilon:\\r\\n if self.cond == True:\\r\\n self.Epsilon = self.d_T * self.thermal_conductivity\\r\\n else:\\r\\n self.Epsilon = (self.diff_scale ** 2) / \\\\\\r\\n (3.0 * self.absorb_coeffs[self.rad] ** 2)\\r\\n # Beta:\\r\\n if self.cond == True:\\r\\n self.Beta = (self.diff_scale * self.thermal_conductivity) / \\\\\\r\\n (self.convect_coeff)\\r\\n else:\\r\\n self.Beta = (1.0 + 3.0 * self.r2) * (2.0 * self.diff_scale) / \\\\\\r\\n ((1.0 - 2.0 * self.r1) * (\\r\\n 3.0 * self.absorb_coeffs[self.rad]))\\r\\n\\r\\n # The feild solutions at the last timestep.\\r\\n # The integral vF:\\r\\n if self.cond == True:\\r\\n # The horrifically complicated F:\\r\\n def F_func_cond(elem, eta):\\r\\n F = 0.0\\r\\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n F += Tn\\r\\n for k in range(0, len(self.fq_list)):\\r\\n vk = self.fq_list[k]\\r\\n try:\\r\\n vk_m = self.fq_list[k - 1]\\r\\n except:\\r\\n vk_m = self.v0_frequency\\r\\n absorbtion = self.absorb_coeffs[k]\\r\\n phi = elem.eval_elem(self.node_map, self.lst_rad[k],\\r\\n [eta])[0]\\r\\n inter1 = phi - 4.0 * sconst.pi * \\\\\\r\\n self.B_int_function(Tn, self.refr_idx_vol,\\r\\n vk, vk_m)\\r\\n inter2 = absorbtion * self.d_T / (self.diff_scale ** 2)\\r\\n F += inter2 * inter1\\r\\n return elem.funcs(eta) * F\\r\\n if not no_rad:\\r\\n # We're integrating something non-linear for SP1\\r\\n self.vF_vect_vol = et.elems_2_array(self.mesh,\\r\\n F_func_cond,\\r\\n self.node_map)\\r\\n else:\\r\\n # Or something easier if we're only looking at heat.\\r\\n self.vF_vect_vol = np.array(self.uv_vol * lst_tmp).reshape(-1)\\r\\n else:\\r\\n def F_func_radiative(elem, eta):\\r\\n T = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n vk = self.fq_list[self.rad]\\r\\n try:\\r\\n vk_minus = self.fq_list[self.rad - 1]\\r\\n except:\\r\\n vk_minus = self.v0_frequency\\r\\n n = self.refr_idx_vol\\r\\n F = 4.0 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\\r\\n return elem.funcs(eta) * F\\r\\n\\r\\n self.vF_vect_vol = et.elems_2_array(self.mesh,\\r\\n F_func_radiative,\\r\\n self.node_map)\\r\\n # The path integral vf:\\r\\n if self.cond == True:\\r\\n def f_func_cond(elem, eta):\\r\\n Tb = self.background_temperature\\r\\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n n = self.refr_idx_background\\r\\n vk = self.v0_frequency\\r\\n vk_minus = 0\\r\\n Bb0 = self.B_int_function(Tb, n, vk, vk_minus)\\r\\n Bn0 = self.B_int_function(Tn, n, vk, vk_minus)\\r\\n B_coeff = (self.alpha * sconst.pi) / self.convect_coeff\\r\\n f = Tb + B_coeff * (Bb0 - Bn0)\\r\\n return elem.funcs(eta) * f\\r\\n if not no_rad:\\r\\n self.vf_vect_bound = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n f_func_cond,\\r\\n self.node_map)\\r\\n else:\\r\\n try:\\r\\n self.vf_vect_bound = self.cache_tb_integral_array\\r\\n except AttributeError:\\r\\n def elem_functor(elem, eta): return elem.funcs(eta)\\r\\n self.cache_tb_integral_array = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n elem_functor,\\r\\n self.node_map)\\r\\n self.cache_tb_integral_array *= self.background_temperature\\r\\n self.vf_vect_bound = self.cache_tb_integral_array\\r\\n \\r\\n else:\\r\\n # Radiation f = 4*pi*B^{(k)}(T_b, n_g)\\r\\n def f_func_radiative(elem, eta):\\r\\n T = self.background_temperature\\r\\n vk = self.fq_list[self.rad]\\r\\n try:\\r\\n vk_minus = self.fq_list[self.rad - 1]\\r\\n except:\\r\\n vk_minus = self.v0_frequency\\r\\n n = self.refr_idx_vol\\r\\n f = 4 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\\r\\n return elem.funcs(eta) * f\\r\\n\\r\\n self.vf_vect_bound = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n f_func_radiative,\\r\\n self.node_map)\\r\\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\\r\\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\\r\\n assert (self.vf_vect_bound.shape[0] == \\\\\\r\\n self.vF_vect_vol.shape[0])\",\n \"def eventually(self, t1, t2):\\n new_robustness = lambda s, t : max([ self.robustness(s,k) for k in range(t+t1, t+t2+1)])\\n\\n new_formula = STLFormula(new_robustness)\\n\\n return new_formula\",\n \"def _manage_infinity_bounds(problem, _bounds, get_bound, set_bound):\\n for variable in problem.variables:\\n expr_bounds = get_bound(variable)\\n lower_bound = expr_bounds.lower_bound\\n upper_bound = expr_bounds.upper_bound\\n\\n if is_inf(lower_bound):\\n new_lower_bound = None\\n else:\\n new_lower_bound = lower_bound\\n\\n if is_inf(upper_bound):\\n new_upper_bound = None\\n else:\\n new_upper_bound = upper_bound\\n\\n set_bound(variable, Interval(new_lower_bound, new_upper_bound))\",\n \"def calculateExteriorElementBoundaryQuadrature(self):\\n #\\n #get physical locations of element boundary quadrature points\\n #\\n #assume all components live on the same mesh\\n self.u[0].femSpace.elementMaps.getValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\\n self.ebqe['x'])\\n #\\n #get metric tensor and unit normals\\n #\\n if self.movingDomain:\\n if self.tLast_mesh != None:\\n self.ebqe['xt'][:]=self.ebqe['x']\\n self.ebqe['xt']-=self.ebqe['x_last']\\n alpha = 1.0/(self.t_mesh - self.tLast_mesh)\\n self.ebqe['xt']*=alpha\\n else:\\n self.ebqe['xt'][:]=0.0\\n self.ebqe['x_last'][:]=self.ebqe['x']\\n self.u[0].femSpace.elementMaps.getJacobianValuesGlobalExteriorTrace_movingDomain(self.elementBoundaryQuadraturePoints,\\n self.ebqe['xt'],\\n self.ebqe['inverse(J)'],\\n self.ebqe['g'],\\n self.ebqe['sqrt(det(g))'],\\n self.ebqe['n'])\\n else:\\n self.u[0].femSpace.elementMaps.getJacobianValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\\n self.ebqe['inverse(J)'],\\n self.ebqe['g'],\\n self.ebqe['sqrt(det(g))'],\\n self.ebqe['n'])\\n #now map the physical points back to the reference element\\n #assume all components live on same mesh\\n self.u[0].femSpace.elementMaps.getInverseValuesGlobalExteriorTrace(self.ebqe['inverse(J)'],self.ebqe['x'],self.ebqe['hat(x)'])\\n #\\n #since the points on the reference boundary may be reordered on many right element boundaries, we\\n #have to use an array of reference boundary points on all element boundaries\\n #first copy the left reference element boundary quadrature points from the reference element boundary\\n self.testSpace[0].getBasisValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\\n self.ebqe[('w',0)])\\n cfemIntegrals.calculateWeightedShapeGlobalExteriorTrace(self.mesh.exteriorElementBoundariesArray,\\n self.mesh.elementBoundaryElementsArray,\\n self.mesh.elementBoundaryLocalElementBoundariesArray,\\n self.elementBoundaryQuadratureWeights[('f',0)],\\n self.ebqe['sqrt(det(g))'],\\n self.ebqe[('w',0)],\\n self.ebqe[('w*dS_f',0)])\\n self.u[0].femSpace.getBasisGradientValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\\n self.ebqe['inverse(J)'],\\n self.ebqe[('grad(v)',0)])\\n #setup flux boundary conditions\\n self.fluxBoundaryConditionsObjectsDict = dict([(cj,FluxBoundaryConditions(self.mesh,\\n self.nElementBoundaryQuadraturePoints_elementBoundary,\\n self.ebqe[('x')],\\n self.advectiveFluxBoundaryConditionsSetterDict[cj],\\n self.diffusiveFluxBoundaryConditionsSetterDictDict[cj]))\\n for cj in self.advectiveFluxBoundaryConditionsSetterDict.keys()])\\n self.ebqe['dS'] = numpy.zeros((self.mesh.nExteriorElementBoundaries_global,self.nElementBoundaryQuadraturePoints_elementBoundary),'d')\\n cfemIntegrals.calculateIntegrationWeights(self.ebqe['sqrt(det(g))'],\\n self.elementBoundaryQuadratureWeights[('u',0)],\\n self.ebqe['dS'])\\n for ci in range(self.nc): self.ebqe[('dS',ci)] = self.ebqe['dS']\\n #\\n self.ellamDiscretization.calculateExteriorElementBoundaryQuadrature(self.ebqe)\\n #\\n self.coefficients.initializeGlobalExteriorElementBoundaryQuadrature(self.timeIntegration.t,self.ebqe)\",\n \"def R_term(\\n enst, # enstrophy field\\n omega1, # vorticity-1 component\\n omega2, # vorticity-2 component\\n omega3, # vorticity-3 component\\n s11, # strain rate-11 component\\n s12, # strain rate-12 component\\n s13, # strain rate-13 component\\n s22, # strain rate-22 component\\n s23, # strain rate-23 component\\n s33, # strain rate-33 component\\n diff = False): # differentiation flag\\n #---------------------------------------------------------------------#\\n # Defining domain variables #\\n #---------------------------------------------------------------------#\\n pi = np.pi # pi\\n dx = (2.0*pi)/64.0 # spatial step\\n nu = 0.000185 # default viscosity\\n #---------------------------------------------------------------------#\\n # Spectral differentiation variables #\\n #---------------------------------------------------------------------#\\n dim = 64\\n kspec = np.fft.fftfreq(dim) * dim\\n Kfield = np.array(np.meshgrid(kspec, kspec, kspec, indexing='ij'))\\n #---------------------------------------------------------------------#\\n # Spectral differentiation variables #\\n #---------------------------------------------------------------------#\\n term1 = np.zeros((dim, dim, dim))\\n term2 = np.zeros((dim, dim, dim))\\n term3 = np.zeros((dim, dim, dim))\\n #---------------------------------------------------------------------#\\n # Numerator (numpy gradient tool) #\\n #---------------------------------------------------------------------#\\n if diff is not False:\\n term1 = np.gradient(enst,dx, edge_order=2)[0]\\n term2 = np.gradient(enst,dx, edge_order=2)[1]\\n term3 = np.gradient(enst,dx, edge_order=2)[2]\\n #---------------------------------------------------------------------#\\n # Numerator (spectral differentiation) #\\n #---------------------------------------------------------------------#\\n else:\\n term1 = 0.5*np.fft.ifftn(1j*Kfield[0]*np.fft.fftn(enst) +\\\\\\n 1j*Kfield[0]*np.fft.fftn(enst)).real\\n term2 = 0.5*np.fft.ifftn(1j*Kfield[1]*np.fft.fftn(enst) +\\\\\\n 1j*Kfield[1]*np.fft.fftn(enst)).real\\n term3 = 0.5*np.fft.ifftn(1j*Kfield[2]*np.fft.fftn(enst) +\\\\\\n 1j*Kfield[2]*np.fft.fftn(enst)).real\\n #---------------------------------------------------------------------#\\n # Numerator #\\n #---------------------------------------------------------------------#\\n num = nu*(term1**2.0+ term2**2.0 + term3**2.0)\\n #---------------------------------------------------------------------#\\n # Denominator #\\n #---------------------------------------------------------------------#\\n den = omega1*s11*omega1 + omega1*s12*omega2 + omega1*s13*omega3 +\\\\\\n omega2*s12*omega1 + omega2*s22*omega2 + omega2*s23*omega3+\\\\\\n omega3*s13*omega1 + omega3*s23*omega2 + omega3*s33*omega3\\n #---------------------------------------------------------------------#\\n # R calculation #\\n #---------------------------------------------------------------------#\\n R = num/den\\n\\n return R\",\n \"def update_boundary(self):\\n\\n cell = self._fire_boundary.dequeue()\\n neighbors = self.four_neighbors(cell[0], cell[1])\\n #neighbors = self.eight_neighbors(cell[0], cell[1])\\n for neighbor in neighbors:\\n if self.is_empty(neighbor[0], neighbor[1]):\\n self.set_full(neighbor[0], neighbor[1])\\n self._fire_boundary.enqueue(neighbor)\\n\\n # Check class invariant after update\\n assert self.boundary_invariant()\",\n \"def do(self, variables, values):\\n intervened = LinearGaussianBN()\\n sym_values = [Symbol(val) if isinstance(val, str) else val for val in values]\\n var_to_value = dict(zip(variables, sym_values))\\n for variable in self.variables:\\n if variable not in variables:\\n new_parents = []\\n new_weights = [self._weights[variable][0]]\\n for indx, p in enumerate(self.parents(variable)):\\n w = self._weights[variable][indx + 1]\\n if p not in variables:\\n new_parents.append(p)\\n new_weights.append(w)\\n else:\\n new_weights[0] += w * var_to_value[p]\\n\\n intervened.add_var(variable, new_parents, new_weights)\\n\\n return intervened\",\n \"def SetPRCatConstraint(self, model ) :\\n tot = np.multiply(self.wish, self.dispo)\\n for line in tot :\\n for val in line :\\n if not val : continue\\n if self.bound>0 : model += val <= self.valBound\\n elif self.bound<0 : model += val >= self.valBound\",\n \"def terms(self, terms):\\n\\n self._terms = terms\",\n \"def set_weight(term, irrelevant):\\n if term in irrelevant:\\n return (0.2 * max([x/sum(indtf_features[term]) for x in indtf_features[term]]))\\n elif isinstance(term, tuple):\\n return len(term)\\n else:\\n return 1\",\n \"def _compute_forces(self):\\n # get new coeffs\\n self._get_coeffs()\\n\\n # instead of writing many time\\n awa = self.awa / 180.0 * np.pi\\n\\n # lift and drag\\n self.lift = 0.5 * self.rho * self.aws ** 2 * self.area * self.cl\\n self.drag = 0.5 * self.rho * self.aws ** 2 * self.area * self.cd + self._get_Rw(awa)\\n\\n # project into yacht coordinate system\\n self.Fx = self.lift * np.sin(awa) - self.drag * np.cos(awa)\\n self.Fy = self.lift * np.cos(awa) + self.drag * np.sin(awa)\\n\\n # heeling moment\\n self.Mx = self.Fy * self._vce() * np.cos(self.phi / 180.0 * np.pi)\\n\\n # side-force is horizontal component of Fh\\n self.Fy *= np.cos(np.deg2rad(self.phi))\",\n \"def initialize_constants(self):\\n # maximum pheromone value\\n self.PH_MAX = np.float_( len(self.variables) / (1.0 - self.PH_REDUCE_FACTOR))\\n # minimum pheromone value\\n self.PH_MIN = np.float_(self.PH_MAX / (2*len(self.variables)) )\",\n \"def _solve_freq_rb(self, d, v, a, force, freqw, freqw2, incrb, unc):\\n if self.rbsize and incrb:\\n rb = self.rb\\n if self.m is not None:\\n if unc:\\n a_rb = self.invm[self._rb] * force[rb]\\n else:\\n a_rb = la.lu_solve(self.imrb, force[rb], check_finite=False)\\n else:\\n a_rb = force[rb]\\n if \\\"d\\\" in incrb or \\\"v\\\" in incrb:\\n pvnz = freqw != 0\\n if \\\"v\\\" in incrb:\\n v[rb, pvnz] = (-1j / freqw[pvnz]) * a_rb[:, pvnz]\\n if \\\"d\\\" in incrb:\\n d[rb, pvnz] = (-1.0 / freqw2[pvnz]) * a_rb[:, pvnz]\\n if \\\"a\\\" in incrb:\\n a[rb] = a_rb\",\n \"def test_basic_handling_range_with_variable_bounds(spark_ctx):\\n\\n dr = Drudge(spark_ctx)\\n\\n j1, j2 = symbols('j1 j2')\\n m1, m2 = symbols('m1, m2')\\n j_max = symbols('j_max')\\n j = Range('j', 0, j_max)\\n m = Range('m')\\n dr.set_dumms(j, [j1, j2])\\n dr.set_dumms(m, [m1, m2])\\n\\n v = Vec('v')\\n x = IndexedBase('x')\\n tensor = dr.sum((j2, j), (m2, m[0, j2]), x[j2, m2] * v[j2, m2])\\n\\n reset = tensor.reset_dumms()\\n assert reset.n_terms == 1\\n term = reset.local_terms[0]\\n assert len(term.sums) == 2\\n if term.sums[0][1].label == 'j':\\n j_sum, m_sum = term.sums\\n else:\\n m_sum, j_sum = term.sums\\n assert j_sum[0] == j1\\n assert j_sum[1].args == j.args\\n assert m_sum[0] == m1\\n assert m_sum[1].label == 'm'\\n assert m_sum[1].lower == 0\\n assert m_sum[1].upper == j1 # Important!\\n assert term.amp == x[j1, m1]\\n assert term.vecs == (v[j1, m1],)\\n\\n # Test that functions can be mapped to the bounds.\\n repled = reset.map2scalars(\\n lambda x: x.xreplace({j_max: 10}), skip_ranges=False\\n )\\n assert repled.n_terms == 1\\n term = repled.local_terms[0]\\n checked = False\\n for _, i in term.sums:\\n if i.label == 'j':\\n assert i.lower == 0\\n assert i.upper == 10\\n checked = True\\n continue\\n assert checked\",\n \"def force ( r, e ):\\n from math import isclose\\n\\n # Parameters of the Gay-Berne potential \\n # \\n # The key parameters are \\n # mu, nu ................ the exponents \\n # kappa and kappa' ....... the anisotropies \\n # kappa is the ratio of intermolecular separations \\n # sigma_e / sigma_s i.e. end-to-end / side-by-side \\n # kappa' is the ratio of well depths \\n # epsilon_s / epsilon_e i.e. side-by-side / end-to-end \\n # The derived parameters are chi and chi' \\n # chi = (kappa**2 - 1) / (kappa**2+1) \\n # chi' = (z - 1) / (z + 1)\\n # where z = (kappa') ** ( 1 / mu ) \\n # \\n # For convenience kappa' is spelt xappa, chi' is spelt xhi\\n # We choose units such that sigma_s = 1.0 and epsilon_0 = 1.0\\n # Two of the following three varieties should be commented out\\n\\n # Original Gay-Berne-deMiguel potential [J. Chem. Phys, 74, 3316; Mol. Phys. 74, 405 (1991)]\\n mu, nu, kappa, xappa = 2, 1, 3.0, 5.0\\n\\n # # Luckhurst-Phippen potential [Liq. Cryst., 8, 451 (1990)]\\n # mu, nu, kappa, xappa = 1, 2, 3.0, 5.0\\n\\n # # Berardi-Zannoni potential [J. Chem. Soc. Faraday Trans., 89, 4069 (1993)]\\n # mu, nu, kappa, xappa = 1, 3, 3.0, 5.0\\n\\n # Derived parameters\\n chi = (kappa**2 - 1.0) / (kappa**2+1.0)\\n xhi = (xappa**(1.0/mu) - 1.0) / (xappa**(1.0/mu) + 1.0)\\n\\n # Cutoff distance; normally we would use a larger value\\n r_cut = 4.0\\n \\n assert r.shape == (n,3), 'Incorrect shape of r'\\n assert e.shape == (n,3), 'Incorrect shape of e'\\n\\n # Notation to match appendix\\n i = 0\\n j = 1\\n\\n ei = e[i,:]\\n ej = e[j,:]\\n assert isclose(np.sum(ei**2),1.0), 'Non-unit vector {} {} {}'.format(*ei)\\n assert isclose(np.sum(ej**2),1.0), 'Non-unit vector {} {} {}'.format(*ej)\\n\\n rij = r[i,:] - r[j,:]\\n rij_mag = np.sqrt( np.sum(rij**2) ) # Magnitude of separation vector\\n sij = rij / rij_mag # Unit vector\\n ci = np.dot( ei, sij )\\n cj = np.dot( ej, sij )\\n cij = np.dot( ei, ej )\\n cp = ci + cj\\n cm = ci - cj\\n\\n # Sigma formula\\n cpchi = cp/(1.0+chi*cij)\\n cmchi = cm/(1.0-chi*cij)\\n sigma = 1.0/np.sqrt(1.0-0.5*chi*(cp*cpchi+cm*cmchi))\\n\\n # Epsilon formula\\n eps1 = 1.0/np.sqrt(1.0-(chi*cij)**2) # Depends on chi, not xhi\\n cpxhi = cp/(1.0+xhi*cij)\\n cmxhi = cm/(1.0-xhi*cij)\\n eps2 = 1.0-0.5*xhi*(cp*cpxhi+cm*cmxhi) # Depends on xhi\\n epsilon = (eps1**nu) * (eps2**mu)\\n\\n # Potential at rij\\n rho = rij_mag - sigma + 1.0\\n rho6 = 1.0 / rho**6\\n rho12 = rho6**2\\n rhoterm = 4.0*(rho12 - rho6) # Needed for forces and torques\\n drhoterm = -24.0 * (2.0 * rho12 - rho6) / rho # Needed for forces and torques\\n pot = epsilon*rhoterm\\n\\n # Potential at r_cut\\n rho = r_cut - sigma + 1.0\\n rho6 = 1.0 / rho**6\\n rho12 = rho6**2\\n cutterm = 4.0*(rho12 - rho6) # Needed for cutoff forces and torques\\n dcutterm = -24.0 * (2.0 * rho12 - rho6) / rho # Needed for cutoff forces and torques\\n pot = pot - epsilon * cutterm\\n\\n # Derivatives of sigma\\n prefac = 0.5*chi*sigma**3\\n dsig_dci = prefac*(cpchi+cmchi)\\n dsig_dcj = prefac*(cpchi-cmchi)\\n prefac = prefac*(0.5*chi)\\n dsig_dcij = -prefac*(cpchi**2-cmchi**2)\\n\\n # Derivatives of epsilon\\n prefac = -mu*xhi*(eps1**nu)*eps2**(mu-1)\\n deps_dci = prefac*(cpxhi+cmxhi)\\n deps_dcj = prefac*(cpxhi-cmxhi)\\n prefac = prefac*(0.5*xhi)\\n deps_dcij = -prefac*(cpxhi**2-cmxhi**2) # From derivative of eps2\\n deps_dcij = deps_dcij + nu*(chi**2)*(eps1**(nu+2))*(eps2**mu)*cij # From derivative of eps1\\n\\n # Derivatives of potential\\n dpot_drij = epsilon * drhoterm\\n dpot_dci = rhoterm * deps_dci - epsilon * drhoterm * dsig_dci\\n dpot_dcj = rhoterm * deps_dcj - epsilon * drhoterm * dsig_dcj\\n dpot_dcij = rhoterm * deps_dcij - epsilon * drhoterm * dsig_dcij\\n\\n # Standard formula for forces and torque gradients\\n fij = -dpot_drij*sij - dpot_dci*(ei-ci*sij)/rij_mag - dpot_dcj*(ej-cj*sij)/rij_mag\\n gi = dpot_dci*sij + dpot_dcij*ej\\n gj = dpot_dcj*sij + dpot_dcij*ei\\n\\n # Derivatives of potential at cutoff\\n dpot_drij = epsilon * dcutterm\\n dpot_dci = cutterm * deps_dci - epsilon * dcutterm * dsig_dci\\n dpot_dcj = cutterm * deps_dcj - epsilon * dcutterm * dsig_dcj\\n dpot_dcij = cutterm * deps_dcij - epsilon * dcutterm * dsig_dcij\\n\\n # Standard formula for forces and torque gradients (without dpot_drij term)\\n fij = fij + dpot_dci*(ei-ci*sij)/rij_mag + dpot_dcj*(ej-cj*sij)/rij_mag\\n gi = gi - ( dpot_dci*sij + dpot_dcij*ej ) \\n gj = gj - ( dpot_dcj*sij + dpot_dcij*ei ) \\n\\n # Final forces and torques\\n f = np.empty_like(r)\\n t = np.empty_like(r)\\n f[i,:] = fij\\n f[j,:] = -fij\\n t[i,:] = -np.cross(ei,gi)\\n t[j,:] = -np.cross(ej,gj)\\n\\n return pot, f, t\",\n \"def wang(G, term1, term2):\\n if term1 not in G or term2 not in G:\\n return 0\\n sa = s_values(G, term1)\\n sb = s_values(G, term2)\\n sva = sum(sa.values())\\n svb = sum(sb.values())\\n common = set(sa.keys()) & set(sb.keys())\\n cv = sum(sa[c] + sb[c] for c in common)\\n return round(cv / (sva + svb), 3)\",\n \"def calculate_boundaries(self, latmesh=False, mask=None, lat_mask=None,\\n adot=None, U_mask=None, mark_divide=False):\\n s = \\\"::: calculating boundaries :::\\\"\\n print_text(s, cls=self)\\n\\n if lat_mask == None and mark_divide:\\n s = \\\">>> IF PARAMETER <mark_divide> OF calculate_boundaries() IS \\\" + \\\\\\n \\\"TRUE, PARAMETER <lat_mask> MUST BE AN EXPRESSION FOR THE LATERAL\\\" + \\\\\\n \\\" BOUNDARIES <<<\\\"\\n print_text(s, 'red', 1)\\n sys.exit(1)\\n \\n # this function contains markers which may be applied to facets of the mesh\\n self.ff = FacetFunction('size_t', self.mesh)\\n self.ff_acc = FacetFunction('size_t', self.mesh)\\n self.cf = CellFunction('size_t', self.mesh)\\n dofmap = self.Q.dofmap()\\n\\n S = self.S\\n B = self.B\\n \\n # default to all grounded ice :\\n if mask == None:\\n mask = Expression('1.0', element=self.Q.ufl_element())\\n \\n # default to all positive accumulation :\\n if adot == None:\\n adot = Expression('1.0', element=self.Q.ufl_element())\\n \\n # default to U observations everywhere :\\n if U_mask == None:\\n U_mask = Expression('1.0', element=self.Q.ufl_element())\\n\\n self.init_adot(adot)\\n self.init_mask(mask)\\n self.init_U_mask(U_mask)\\n\\n if mark_divide:\\n s = \\\" - marking the interior facets for incomplete meshes -\\\"\\n print_text(s, cls=self)\\n self.init_lat_mask(lat_mask)\\n\\n self.S.set_allow_extrapolation(True)\\n self.B.set_allow_extrapolation(True)\\n self.mask.set_allow_extrapolation(True)\\n self.adot.set_allow_extrapolation(True)\\n self.U_mask.set_allow_extrapolation(True)\\n self.lat_mask.set_allow_extrapolation(True)\\n \\n tol = 1e-6\\n \\n s = \\\" - marking boundaries - \\\"\\n print_text(s, cls=self)\\n\\n if latmesh:\\n s = \\\" - using a lateral surface mesh - \\\"\\n print_text(s, cls=self)\\n \\n class GAMMA_S_GND(SubDomain):\\n def inside(self, x, on_boundary):\\n return mask(x[0], x[1], x[2]) <= 1.0 and on_boundary\\n gamma_s_gnd = GAMMA_S_GND()\\n\\n class GAMMA_S_FLT(SubDomain):\\n def inside(self, x, on_boundary):\\n return mask(x[0], x[1], x[2]) > 1.0 and on_boundary\\n gamma_s_flt = GAMMA_S_FLT()\\n\\n class GAMMA_U_GND(SubDomain):\\n def inside(self, x, on_boundary):\\n return abs(x[2] - S(x[0], x[1], x[2])) < tol \\\\\\n and mask(x[0], x[1], x[2]) <= 1.0 \\\\\\n and U_mask(x[0], x[1], x[2]) <= 0.0 and on_boundary\\n gamma_u_gnd = GAMMA_U_GND()\\n\\n class GAMMA_U_FLT(SubDomain):\\n def inside(self, x, on_boundary):\\n return abs(x[2] - S(x[0], x[1], x[2])) < tol \\\\\\n and mask(x[0], x[1], x[2]) > 1.0 \\\\\\n and U_mask(x[0], x[1], x[2]) <= 0.0 and on_boundary\\n gamma_u_flt = GAMMA_U_FLT()\\n\\n class GAMMA_B_GND(SubDomain):\\n def inside(self, x, on_boundary):\\n return abs(x[2] - B(x[0], x[1], x[2])) < tol \\\\\\n and mask(x[0], x[1], x[2]) <= 1.0 and on_boundary\\n gamma_b_gnd = GAMMA_B_GND()\\n\\n class GAMMA_B_FLT(SubDomain):\\n def inside(self, x, on_boundary):\\n return abs(x[2] - B(x[0], x[1], x[2])) < tol \\\\\\n and mask(x[0], x[1], x[2]) > 1.0 and on_boundary\\n gamma_b_flt = GAMMA_B_FLT()\\n\\n class GAMMA_L_OVR(SubDomain):\\n def inside(self, x, on_boundary):\\n return x[2] > -10 and x[2] < S(x[0], x[1], x[2]) - tol and on_boundary\\n gamma_l_ovr = GAMMA_L_OVR()\\n\\n class GAMMA_L_UDR(SubDomain):\\n def inside(self, x, on_boundary):\\n return x[2] < 10 and x[2] < S(x[0], x[1], x[2]) - tol and on_boundary\\n gamma_l_udr = GAMMA_L_UDR()\\n\\n class GAMMA_L_TRM(SubDomain):\\n def inside(self, x, on_boundary):\\n return lat_mask(x[0], x[1], x[2]) <= 0.0\\n gamma_l_trm = GAMMA_L_TRM()\\n\\n gamma_s_flt.mark(self.ff, self.GAMMA_S_FLT)\\n gamma_s_gnd.mark(self.ff, self.GAMMA_S_GND)\\n gamma_l_ovr.mark(self.ff, self.GAMMA_L_OVR)\\n gamma_l_udr.mark(self.ff, self.GAMMA_L_UDR)\\n gamma_b_flt.mark(self.ff, self.GAMMA_B_FLT)\\n gamma_b_gnd.mark(self.ff, self.GAMMA_B_GND)\\n #gamma_u_flt.mark(self.ff, self.GAMMA_U_FLT)\\n #gamma_u_gnd.mark(self.ff, self.GAMMA_U_GND)\\n #if mark_divide: \\n # gamma_l_trm.mark(self.cf, 1)\\n \\n else :\\n s = \\\" - not using a lateral surface mesh - \\\"\\n print_text(s, cls=self)\\n\\n class GAMMA_GND(SubDomain):\\n def inside(self, x, on_boundary):\\n return mask(x[0], x[1], x[2]) <= 1.0\\n gamma_gnd = GAMMA_GND()\\n\\n class GAMMA_FLT(SubDomain):\\n def inside(self, x, on_boundary):\\n return mask(x[0], x[1], x[2]) > 1.0\\n gamma_flt = GAMMA_FLT()\\n\\n class GAMMA_L_OVR(SubDomain):\\n def inside(self, x, on_boundary):\\n return x[2] > -10 and on_boundary\\n gamma_l_ovr = GAMMA_L_OVR()\\n\\n class GAMMA_L_UDR(SubDomain):\\n def inside(self, x, on_boundary):\\n return x[2] < 10 and on_boundary\\n gamma_l_udr = GAMMA_L_UDR()\\n\\n gamma_flt.mark(self.cf, 1)\\n gamma_gnd.mark(self.cf, 0)\\n gamma_l_ovr.mark(self.ff, self.GAMMA_L_OVR)\\n gamma_l_udr.mark(self.ff, self.GAMMA_L_UDR)\\n \\n # mark the divide if desired : \\n if mark_divide:\\n class GAMMA_L_DVD(SubDomain):\\n def inside(self, x, on_boundary):\\n return lat_mask(x[0], x[1], x[2]) <= 0.0 and on_boundary\\n gamma_l_dvd = GAMMA_L_DVD()\\n gamma_l_dvd.mark(self.ff, self.GAMMA_L_DVD)\\n \\n s = \\\" - done - \\\"\\n print_text(s, cls=self)\\n \\n #s = \\\" - iterating through %i cells - \\\" % self.num_cells\\n #print_text(s, cls=self)\\n #for c in cells(self.mesh):\\n # x_m = c.midpoint().x()\\n # y_m = c.midpoint().y()\\n # z_m = c.midpoint().z()\\n # mask_xy = mask(x_m, y_m, z_m)\\n\\n # if mask_xy > 1:\\n # self.cf[c] = 1\\n # else:\\n # self.cf[c] = 0\\n\\n #s = \\\" - done - \\\"\\n #print_text(s, cls=self)\\n\\n self.ds = Measure('ds')[self.ff]\\n self.dx = Measure('dx')#[self.cf]\\n \\n self.dx_g = self.dx(0) # internal above grounded\\n self.dx_f = self.dx(1) # internal above floating\\n self.dBed_g = self.ds(3) # grounded bed\\n self.dBed_f = self.ds(5) # floating bed\\n self.dBed = self.ds(3) + self.ds(5) # bed\\n self.dSrf_gu = self.ds(8) # grounded with U observations\\n self.dSrf_fu = self.ds(9) # floating with U observations\\n self.dSrf_u = self.ds(8) + self.ds(9) # surface with U observations\\n self.dSrf_g = self.ds(2) + self.ds(8) # surface of grounded ice\\n self.dSrf_f = self.ds(6) + self.ds(9) # surface of floating ice\\n self.dSrf = self.ds(6) + self.ds(2) \\\\\\n + self.ds(8) + self.ds(9) # surface\\n self.dLat_d = self.ds(7) # lateral divide\\n self.dLat_to = self.ds(4) # lateral terminus overwater\\n self.dLat_tu = self.ds(10) # lateral terminus underwater\\n self.dLat_t = self.ds(4) + self.ds(10) # lateral terminus\\n self.dLat = self.ds(4) + self.ds(7) \\\\\\n + self.ds(10) # lateral\",\n \"def chgvarbound(self,j_,lower_,finite_,value_): # 3\\n res = self.__obj.chgvarbound(j_,lower_,finite_,value_)\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\",\n \"def add_bcs(self, RHS, bc_left, cff0 ,cff1, cff2):\\n RHS[0] += cff0 * self.c[0]/(2*self.dx)*bc_left\\n RHS[0] += cff1 * self.c[0]/(2*self.dx)*self.bcs[1]\\n RHS[0] += cff2 * self.c[0]/(2*self.dx)*self.bcs[2]\",\n \"def _para_boosting(self, H):\\n # print '----------------primal-dual boost-------------------'\\n H = np.hstack((H, -H))\\n # H_ft = np.asfortranarray((H.copy()))\\n (n, p) = H.shape\\n self.c = np.log(n*p)\\n nu = int(n * self.ratio)\\n\\n if self.max_iter < 50:\\n delta = 1\\n else:\\n delta = 40\\n d = np.ones(n) / n\\n d_bar = np.ones(n) / n\\n a_bar = np.ones(p) / p\\n a = np.ones(p) / p\\n h_a = np.sum(H, axis=1) / p\\n h_a_bar = h_a.copy()\\n # a_bar = a\\n # a_tilde = np.ones(p) / p\\n h_a_tilde = h_a.copy()\\n # d_tilde = np.zeros(p)\\n theta = 1\\n sig = 1\\n tau = 1\\n t = 0\\n logscale = 0\\n for t in range(self.max_iter):\\n d = prox_mapping(h_a_tilde, d, tau, 2)\\n if self.has_dcap:\\n d2 = proj_cap_ent(d, 1.0 / nu)\\n # d_new = d_new/d_new.sum()\\n if np.abs(d.sum() - d2.sum()) > 0.0001:\\n print 'error'\\n d = d2\\n d_tilde = d\\n dtH = np.dot(d_tilde, H)\\n # dtH = np.dot(H.T, d_tilde)\\n a_new = prox_mapping(-dtH, a, sig, 2)\\n h_a_new = np.dot(H, a_new)\\n # a_tilde = a_new + theta * (a_new - a)\\n h_a_tilde = (1+theta) * h_a_new - theta * h_a\\n a = a_new\\n h_a = h_a_new\\n d_bar *= t / (t + 1.0)\\n d_bar += 1.0 / (t + 1) * d\\n a_bar *= t / (t + 1.0)\\n a_bar += 1.0 / (t + 1) * a\\n # h_a_bar = np.dot(H, a_bar)\\n h_a_bar = t / (t + 1.0) * h_a_bar + 1.0/(t+1) * h_a\\n if int(np.log(t+1)) == logscale:\\n logscale += 1\\n self.iter_num.append(t)\\n if self.has_dcap:\\n min_margin = ksmallest2(h_a_bar, nu)\\n self.primal_obj.append(-np.mean(min_margin))\\n else:\\n self.primal_obj.append(- np.min(h_a_bar))\\n self.margin.append(-self.primal_obj[-1])\\n self.dual_obj.append(-np.max(np.dot(d_bar, H)))\\n self.gap.append(self.primal_obj[-1] - self.dual_obj[-1])\\n self.err_tr.append(np.mean(h_a_bar < 0))\\n # if t % 100 == 0:\\n # print 'iter ' + str(t) + ' ' + str(self.gap[-1])\\n if self.gap[-1] < self.epsi:\\n break\\n self.alpha = a_bar[:p / 2] - a_bar[p / 2:]\\n self.d = d_bar\\n print \\\" pd-boosting(python): max iter#%d: , actual iter#%d\\\" % (self.max_iter, t)\",\n \"def convergence_check(self):\\n air = self.air_alias.val\\n flue_gas = self.fuel_alias.val + '_fg'\\n fuel = self.fuel_alias.val\\n\\n for c in self.outl:\\n if not c.fluid.val_set[air]:\\n if c.fluid.val[air] > 0.95:\\n c.fluid.val[air] = 0.95\\n if c.fluid.val[air] < 0.5:\\n c.fluid.val[air] = 0.5\\n\\n if not c.fluid.val_set[flue_gas]:\\n if c.fluid.val[flue_gas] > 0.5:\\n c.fluid.val[flue_gas] = 0.5\\n if c.fluid.val[flue_gas] < 0.05:\\n c.fluid.val[flue_gas] = 0.05\\n\\n if not c.fluid.val_set[fuel]:\\n if c.fluid.val[fuel] > 0:\\n c.fluid.val[fuel] = 0\\n\\n c.target.propagate_fluid_to_target(c, c.target)\\n\\n for i in self.inl:\\n if i.m.val_SI < 0 and not i.m.val_set:\\n i.m.val_SI = 0.01\\n\\n for c in self.outl:\\n if c.m.val_SI < 0 and not c.m.val_set:\\n c.m.val_SI = 10\\n c.target.propagate_fluid_to_target(c, c.target)\\n\\n if self.lamb.val < 1 and not self.lamb.is_set:\\n self.lamb.val = 2\",\n \"def _add_unconformity_below(self, feature):\\n for f in self.features:\\n if f.type == 'series' and feature.feature.name != f.name:\\n f.add_region(lambda pos: ~feature.evaluate(pos))\\n # for f in reversed(self.features):\\n # if f.type == 'unconformity':\\n # feature.add_region(lambda pos: f.evaluate(pos))\\n # break\\n # feature.add_region(lambda pos: ~uc.evaluate(pos))\",\n \"def add_cp_qe_RBM_terms(K, cons_pot_mesh, quad_geo_mesh):\\n num_faces = cons_pot_mesh.get_faces().shape[0]\\n x_c = quad_geo_mesh.get_centroid()\\n w = quad_geo_mesh.get_w()\\n A_m = quad_geo_mesh.get_A_m()\\n S_D = quad_geo_mesh.get_surface_area()\\n\\n for face_num in range(num_faces):\\n face_nodes = quad_geo_mesh.get_tri_nodes(face_num)\\n face_hs = quad_geo_mesh.get_hs(face_num)\\n def v_quad(_xi, _eta, _nodes):\\n return np.identity(3)\\n v_sub_mat = (1. / S_D) * gq.int_over_tri_quad(v_quad, face_nodes, face_hs)\\n def omega_quad(xi, eta, nodes):\\n pos = geo.quadratic_interp(xi, eta, nodes)\\n X = pos - x_c\\n return np.einsum(\\\"lrs,s->lr\\\", geo.LC_3, X)\\n tmp_omega = gq.int_over_tri_quad(\\n omega_quad,\\n face_nodes,\\n face_hs,\\n )\\n tmp_arr = []\\n for m in range(3):\\n tmp_arr.append((1./ A_m[m]) * np.outer(w[m], np.einsum(\\\"l,ls\\\", w[m], tmp_omega)))\\n tmp_arr = np.array(tmp_arr)\\n tmp_omega_mat = np.sum(tmp_arr, axis=0)\\n for src_num in range(num_faces):\\n K[(3 * src_num):(3 * src_num + 3),\\n (3 * face_num):(3 * face_num + 3)] += v_sub_mat\\n src_center = cons_pot_mesh.get_node(src_num)\\n X_0 = src_center - x_c\\n omega_mat = np.einsum(\\\"ijk,js,k->is\\\", geo.LC_3, tmp_omega_mat, X_0)\\n K[(3 * src_num):(3 * src_num + 3),\\n (3 * face_num):(3 * face_num + 3)] += omega_mat\",\n \"def restrict(self):\\n\\n cg = self.grid.coarse_like(2)\\n\\n c_edge_coeffs = EdgeCoeffs(cg, None, empty=True)\\n\\n c_eta_x = cg.scratch_array()\\n c_eta_y = cg.scratch_array()\\n\\n fg = self.grid\\n\\n c_eta_x[cg.ilo:cg.ihi+2,cg.jlo:cg.jhi+1] = \\\\\\n 0.5*(self.x[fg.ilo:fg.ihi+2:2,fg.jlo :fg.jhi+1:2] +\\n self.x[fg.ilo:fg.ihi+2:2,fg.jlo+1:fg.jhi+1:2])\\n\\n # redo the normalization\\n c_edge_coeffs.x = c_eta_x*fg.dx**2/cg.dx**2\\n\\n c_eta_y[cg.ilo:cg.ihi+1,cg.jlo:cg.jhi+2] = \\\\\\n 0.5*(self.y[fg.ilo :fg.ihi+1:2,fg.jlo:fg.jhi+2:2] +\\n self.y[fg.ilo+1:fg.ihi+1:2,fg.jlo:fg.jhi+2:2])\\n\\n c_edge_coeffs.y = c_eta_y*fg.dy**2/cg.dy**2\\n\\n return c_edge_coeffs\",\n \"def _update_conformers(self, cutoff=0.002):\\n logger.debug(\\\"Updating conformers based on occupancy\\\")\\n\\n # Check that all arrays match dimensions.\\n assert len(self._occupancies) == len(self._coor_set) == len(self._bs)\\n\\n # Filter all arrays & lists based on self._occupancies\\n # NB: _coor_set and _bs are lists (not arrays). We must compress, not slice.\\n filterarray = self._occupancies >= cutoff\\n self._occupancies = self._occupancies[filterarray]\\n self._coor_set = list(itertools.compress(self._coor_set, filterarray))\\n self._bs = list(itertools.compress(self._bs, filterarray))\\n\\n logger.debug(f\\\"Remaining valid conformations: {len(self._coor_set)}\\\")\",\n \"def normalize_bounds(self, bounds):\\n scaled_bounds = []\\n scalings = []\\n intercepts = []\\n \\n non_fixed_params = []\\n \\n print(self.device)\\n \\n for name, domain in self.bounds.items():\\n # Get any fixed parmeters\\n if type(domain) == int or type(domain) == float:\\n # Take note\\n self.fixed_parameters.append(name)\\n\\n # Free parameters\\n elif type(domain) == tuple:\\n # Bookkeeping\\n self.free_parameters.append(name)\\n\\n # Get scaling\\n lower_bound = min(domain)\\n upper_bound = max(domain)\\n scale = upper_bound - lower_bound\\n\\n # Transform to [0, 1] domain\\n #scaled_bound = {'name': name, 'type': 'continuous', 'domain': (0., 1.)} #torch.adjustment required\\n non_fixed_params.append(name)\\n \\n # Store\\n #scaled_bounds.append(scaled_bound)\\n scalings.append(scale)\\n intercepts.append(lower_bound)\\n else:\\n raise ValueError(\\\"Domain bounds not understood\\\")\\n \\n n_hyperparams = len(non_fixed_params)\\n \\n scaled_bounds = cat([zeros(1,n_hyperparams, device = self.device), \\n ones(1, n_hyperparams, device = self.device)], 0)\\n return scaled_bounds, tensor(scalings, device = self.device, requires_grad = False), tensor(intercepts, device = self.device, requires_grad = False) #torch.adjustment required\",\n \"def always(self, t1, t2):\\n new_robustness = lambda s, t : min([ self.robustness(s,k) for k in range(t+t1, t+t2+1)])\\n\\n new_formula = STLFormula(new_robustness)\\n\\n return new_formula\",\n \"def _bowl_params(self):\\n self.vars['bowl_strength'] = self.bowl.strength + \\\\\\n self.vars['beta_min_offset']\\n self.vars['q_init'] = self.vars['bowl_strength']\\n if self.vars['bowl_strength'] <= self.vars['beta_min_offset']:\\n print(\\n f\\\"Bowl overflow -- Set to the minimum value : {self.vars['beta_min_offset']}\\\")\\n # raise ValueError(\\\"Bowl overflow... strength lower than set tolerance. Modify the tolerance or fix the bug!\\\")\\n self.vars['bowl_strength'] = self.vars['beta_min_offset']\\n if self.vars['bowl_strength'] > self.vars['q_max']:\\n self.vars['bowl_strength'] = self.vars['q_max']\\n\\n self.vars['zeta_bowl'] = self.toNeural(self.bowl.center)\\n print(f\\\"Value for Q set to {self.vars['bowl_strength']}\\\")\",\n \"def relax(self,n=1):\\n # print(\\\"putin\\\", self.level.rhs.reshape(-1)[:])\\n # print(\\\"getout\\\", self.solver(self.level.rhs.reshape(-1)))\\n for i in range(n):\\n self.level.mid[:] += (self.solver(self.level.rhs.reshape(-1)) -\\n self.solver(self.stencil.eval_convolve(\\n self.level.evaluable_view(self.stencil)).reshape(-1))).reshape(self.level.mid.shape)\",\n \"def compute_bounds(self):\\n # Note: linear_constraints object has been been populated at this stage\\n L_zero_var = []\\n \\n for constraint in self._linear_constraints.L_linear_constraints:\\n lhs_string = constraint[0]\\n rhs_string = constraint[1]\\n if float(rhs_string)==0:\\n #print \\\"rhs=0: forcing the variables to zero\\\"\\n L_vars = re.split(r'[+-]',lhs_string)\\n \\n for var in L_vars:\\n modform_var = var.strip()\\n \\n # forcing all the variables in this constraint to be zero\\n self._linear_constraints.modform_space.D_PuLP_variables[modform_var] = pulp.LpVariable(modform_var, lowBound=0, upBound=0)\\n #print \\\"var forced to zero: \\\", modform_var\\n L_zero_var.append(modform_var)\\n else: #if float(rhs)==0\\n continue\\n \\n if len(L_zero_var)>0:\\n print \\\"\\\\n####### Variables forced to zero (rhs = 0) ##########\\\"\\n print \\\"variables forced to zero: \\\", set(L_zero_var)\\n \\n feasible_lc = flc.FeasibleLinearConstraints(self._linear_constraints)\\n \\n feasible_lc.get_feasible_linear_constraints()\\n \\n feasible_linear_constraints = feasible_lc.feasible_linear_constraints\\n \\n lp_solver = lps.LinearProgrammingSolver(feasible_linear_constraints)\\n \\n D_lower_bounds = {}; D_upper_bounds = {}\\n \\n for v in [self._linear_constraints.modform_space.D_PuLP_variables[k] for k in sorted(self._linear_constraints.modform_space.D_PuLP_variables.keys(), key=gbfunc.natural_keys)]:\\n \\n if str(v) in L_zero_var:\\n D_lower_bounds[str(v)] = '0'\\n D_upper_bounds[str(v)] = '0'\\n continue\\n #end if str(v) in L_zero_var\\n \\n objective_function_PuLP = v\\n \\n list_values_minimize = lp_solver.linear_programming_solver(objective_function_PuLP, pulp.LpMinimize)\\n D_lower_bounds[str(v)] = \\\"%.3f\\\"%round(pulp.value(v),3)\\n \\n list_values_maximize = lp_solver.linear_programming_solver(objective_function_PuLP, pulp.LpMaximize)\\n D_upper_bounds[str(v)] = \\\"%.3f\\\"%round(pulp.value(v),3)\\n\\n #end for v in ..\\n\\n return((D_lower_bounds, D_upper_bounds))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59818715","0.59583765","0.5903426","0.5859693","0.58076525","0.5784628","0.5665552","0.5640563","0.5586638","0.5551454","0.5532172","0.5490747","0.54334694","0.5426477","0.5416738","0.54091454","0.54014874","0.5349996","0.5336917","0.5335465","0.5335465","0.5327792","0.53235096","0.53171754","0.52862585","0.5286126","0.52795374","0.52350026","0.523473","0.52281195","0.52152044","0.5211846","0.52066374","0.5200392","0.51949877","0.5190858","0.5179017","0.5176687","0.51725304","0.5138671","0.51377785","0.51370454","0.51346236","0.51314384","0.5107714","0.5089548","0.50882864","0.5079448","0.50671107","0.5058447","0.504425","0.5044169","0.5032889","0.5016049","0.5009389","0.50070435","0.5004968","0.4999103","0.4997135","0.4995988","0.4993837","0.49903342","0.49811462","0.49760035","0.49667865","0.49652836","0.49636626","0.49630532","0.49612683","0.49534422","0.49524117","0.49512905","0.49471015","0.4942343","0.4937082","0.49336612","0.4916538","0.4915296","0.49150586","0.49141994","0.4910184","0.49044964","0.49002346","0.4898402","0.48934296","0.48883748","0.4887256","0.48841408","0.48771104","0.48732433","0.48509958","0.485082","0.48474","0.48397675","0.48386937","0.4834713","0.48317516","0.48291913","0.4824222"],"string":"[\n \"0.59818715\",\n \"0.59583765\",\n \"0.5903426\",\n \"0.5859693\",\n \"0.58076525\",\n \"0.5784628\",\n \"0.5665552\",\n \"0.5640563\",\n \"0.5586638\",\n \"0.5551454\",\n \"0.5532172\",\n \"0.5490747\",\n \"0.54334694\",\n \"0.5426477\",\n \"0.5416738\",\n \"0.54091454\",\n \"0.54014874\",\n \"0.5349996\",\n \"0.5336917\",\n \"0.5335465\",\n \"0.5335465\",\n \"0.5327792\",\n \"0.53235096\",\n \"0.53171754\",\n \"0.52862585\",\n \"0.5286126\",\n \"0.52795374\",\n \"0.52350026\",\n \"0.523473\",\n \"0.52281195\",\n \"0.52152044\",\n \"0.5211846\",\n \"0.52066374\",\n \"0.5200392\",\n \"0.51949877\",\n \"0.5190858\",\n \"0.5179017\",\n \"0.5176687\",\n \"0.51725304\",\n \"0.5138671\",\n \"0.51377785\",\n \"0.51370454\",\n \"0.51346236\",\n \"0.51314384\",\n \"0.5107714\",\n \"0.5089548\",\n \"0.50882864\",\n \"0.5079448\",\n \"0.50671107\",\n \"0.5058447\",\n \"0.504425\",\n \"0.5044169\",\n \"0.5032889\",\n \"0.5016049\",\n \"0.5009389\",\n \"0.50070435\",\n \"0.5004968\",\n \"0.4999103\",\n \"0.4997135\",\n \"0.4995988\",\n \"0.4993837\",\n \"0.49903342\",\n \"0.49811462\",\n \"0.49760035\",\n \"0.49667865\",\n \"0.49652836\",\n \"0.49636626\",\n \"0.49630532\",\n \"0.49612683\",\n \"0.49534422\",\n \"0.49524117\",\n \"0.49512905\",\n \"0.49471015\",\n \"0.4942343\",\n \"0.4937082\",\n \"0.49336612\",\n \"0.4916538\",\n \"0.4915296\",\n \"0.49150586\",\n \"0.49141994\",\n \"0.4910184\",\n \"0.49044964\",\n \"0.49002346\",\n \"0.4898402\",\n \"0.48934296\",\n \"0.48883748\",\n \"0.4887256\",\n \"0.48841408\",\n \"0.48771104\",\n \"0.48732433\",\n \"0.48509958\",\n \"0.485082\",\n \"0.48474\",\n \"0.48397675\",\n \"0.48386937\",\n \"0.4834713\",\n \"0.48317516\",\n \"0.48291913\",\n \"0.4824222\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.52924377"},"document_rank":{"kind":"string","value":"25"}}},{"rowIdx":87194,"cells":{"query":{"kind":"string","value":"Generate the numerical code."},"document":{"kind":"string","value":"def generate(self, sorder):\n from .generator import For\n from .symbolic import nx, ny, nz, indexed, ix\n\n ns = int(self.stencil.nv_ptr[-1])\n dim = self.stencil.dim\n\n istore, iload, ncond = self._get_istore_iload_symb(dim)\n rhs, _ = self._get_rhs_dist_symb(ncond)\n\n idx = Idx(ix, (0, ncond))\n fstore = indexed(\n \"f\",\n [ns, nx, ny, nz],\n index=[istore[idx, k] for k in range(dim + 1)],\n priority=sorder,\n )\n fload = indexed(\n \"f\",\n [ns, nx, ny, nz],\n index=[iload[0][idx, k] for k in range(dim + 1)],\n priority=sorder,\n )\n\n self.generator.add_routine(\n (\"bounce_back\", For(idx, Eq(fstore, fload + rhs[idx])))\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 code(self):\n if not self._code:\n filename = '<fluxtools function %s>' % self.tag\n self._code = compile(self.math, filename, mode='eval')\n return self._code","def _get_random_number_code(self):\r\n return \"str(random.randint(0, 1e9))\"","def number(self):","def gen_code(self, filename, func_name):\n\n assert self.bits is not None\n\n vd_list = []\n n_vars = 0\n for tree in self.trees:\n vd_list.append(tree.gen_code(n_vars))\n n_vars += len(vd_list[-1])\n\n # checks the type by the suffix\n\n is_v = filename.split(\".\")[-1] == \"v\"\n\n assert self.inputs\n\n f = open(filename, \"w\")\n\n i_bits = np.sum(self.bits[:-1])\n o_bits = self.bits[-1]\n o_sign = self.is_neg[-1]\n\n if is_v:\n f.write(\"module {}(input [{}:0] i, output [{}:0] o);\\n\".format(\n func_name, i_bits-1, o_bits-1))\n else:\n f.write(\"#include<ac_int.h>\\n\\n\")\n f.write(\"void {}(ac_int<{},false> i, ac_int<{},{}> &o)\\n\".format(\n func_name, i_bits, o_bits, o_sign))\n f.write(\"{\\n\")\n\n\n # write function headline\n s_in_line = []\n\n i_bits = self.bits[0]\n i_sign = self.is_neg[0]\n\n if is_v:\n i_datatype = \" wire {}[{}:0] \".format(\n \"signed \" if i_sign else \"\", i_bits-1)\n else:\n i_datatype = \" ac_int<{},{}> \".format(i_bits, i_sign)\n\n len_s = len(i_datatype)\n\n for i in range(self.inputs):\n if is_v:\n s = (\n \"i_\" + str(i) + \" = \" + \"i[\" + str(i_bits*(i+1)-1) + \":\" +\n str(i_bits*i) + \"]\"\n )\n else:\n s = (\n \"i_\" + str(i) + \" = \" + \"i.slc<\" + str(i_bits) + \">(\" +\n str(i_bits*i) + \")\"\n )\n if (\n len_s + len(s) + 2 > 70 or i_bits != self.bits[i] or\n i_sign != self.is_neg[i]\n ):\n f.write(i_datatype + \", \".join(s_in_line) + \";\\n\")\n\n s_in_line = []\n if is_v:\n i_datatype = \" wire {}[{}:0] \".format(\n \"signed \" if i_sign else \"\", i_bits-1)\n else:\n i_datatype = \" ac_int<{},{}> \".format(i_bits, i_sign)\n\n len_s = len(i_datatype)\n\n s_in_line.append(s)\n len_s += len(s) + 2\n\n if s_in_line:\n f.write(i_datatype + \", \".join(s_in_line) + \";\\n\")\n\n if is_v:\n o_datatype = \" wire {}[{}:0] \".format(\n \"signed \" if o_sign else \"\", o_bits)\n else:\n o_datatype = \" ac_int<{},{}> \".format(o_bits, o_sign)\n\n o_list = []\n for i in range(len(vd_list)):\n for v in vd_list[i]:\n if is_v:\n f.write(o_datatype + v + \" = \" + vd_list[i][v] + \";\\n\")\n else:\n f.write(o_datatype + v + \" = \" + vd_list[i][v] + \";\\n\")\n f.write(\"\\n\")\n o_list.append(v)\n\n assert len(o_list) <= 3\n\n if is_v:\n f.write(\" assign \")\n else:\n f.write(\" \")\n\n if len(o_list) == 1:\n f.write(\"o = \" + o_list[0] + \";\")\n elif len(o_list) == 2:\n cond = \"( \" + o_list[0] + \" == \" + o_list[1] + \" ) \"\n n1 = o_list[0]\n n0 = \"( ( \" + \" + \".join(o_list) + \" ) >> 1 )\"\n f.write(\"o = \" + cond + \"? \" + n1 + \": \" + n0)\n elif len(o_list) == 3:\n cond = (\n \"( \" +\n \"( \" + \" == \".join(o_list[0:2]) + \" )?\" + o_list[0] + \":\" +\n \"( \" + \" == \".join(o_list[1:]) + \" )?\" + o_list[1] + \":\" +\n \"( \" + \" == \".join([o_list[0], o_list[2]]) + \" )?\" + o_list[0] +\n \":\" + \"( \" + \" < \".join(o_list[0:2]) + \" ) ?\" +\n \"( ( \" + \" < \".join(o_list[1:]) + \" ) ?\" + o_list[1] + \":\" +\n o_list[2] + \" ) : \" +\n \"( ( \" + \" < \".join([o_list[0], o_list[2]]) + \" ) ?\" + o_list[0] +\n \":\" + o_list[2] + \" )\"\n )\n f.write(\"o = \" + cond + \";\\n\")\n if is_v:\n f.write(\"endmodule\")\n else:\n f.write(\"}\")\n\n f.close()","def nr():\n pass","def generation(x, g):\n return int(x/g)","def gen_numeric_literal(self, expr):\n return self.emit_const(expr.value, expr.typ)","def _gen_code(self):\r\n #TODO: maybe generate one C function only to save compile time? Also easier to take that as a basis and hand craft other covariances??\r\n\r\n #generate c functions from sympy objects \r\n argument_sequence = self._sp_x+self._sp_z+self._sp_theta\r\n code_list = [('k',self._sp_k)]\r\n # gradients with respect to covariance input\r\n code_list += [('dk_d%s'%x.name,dx) for x,dx in zip(self._sp_x,self._sp_dk_dx)]\r\n # gradient with respect to parameters\r\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta,self._sp_dk_dtheta)]\r\n # gradient with respect to multiple output parameters\r\n if self.output_dim > 1:\r\n argument_sequence += self._sp_theta_i + self._sp_theta_j\r\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta_i,self._sp_dk_dtheta_i)]\r\n (foo_c,self._function_code), (foo_h,self._function_header) = \\\r\n codegen(code_list, \"C\",'foobar',argument_sequence=argument_sequence)\r\n #put the header file where we can find it\r\n f = file(os.path.join(tempfile.gettempdir(),'foobar.h'),'w')\r\n f.write(self._function_header)\r\n f.close()\r\n\r\n # Substitute any known derivatives which sympy doesn't compute\r\n self._function_code = re.sub('DiracDelta\\(.+?,.+?\\)','0.0',self._function_code)\r\n\r\n\r\n ############################################################\r\n # This is the basic argument construction for the C code. #\r\n ############################################################\r\n \r\n arg_list = ([\"X2(i, %s)\"%x.name[2:] for x in self._sp_x]\r\n + [\"Z2(j, %s)\"%z.name[2:] for z in self._sp_z])\r\n\r\n # for multiple outputs need to also provide these arguments reversed.\r\n if self.output_dim>1:\r\n reverse_arg_list = list(arg_list)\r\n reverse_arg_list.reverse()\r\n\r\n # Add in any 'shared' parameters to the list.\r\n param_arg_list = [shared_params.name for shared_params in self._sp_theta]\r\n arg_list += param_arg_list\r\n\r\n precompute_list=[]\r\n if self.output_dim > 1:\r\n reverse_arg_list+=list(param_arg_list)\r\n split_param_arg_list = [\"%s1(%s)\"%(theta.name[:-2].upper(),index) for index in ['ii', 'jj'] for theta in self._sp_theta_i]\r\n split_param_reverse_arg_list = [\"%s1(%s)\"%(theta.name[:-2].upper(),index) for index in ['jj', 'ii'] for theta in self._sp_theta_i]\r\n arg_list += split_param_arg_list\r\n reverse_arg_list += split_param_reverse_arg_list\r\n # Extract the right output indices from the inputs.\r\n c_define_output_indices = [' '*16 + \"int %s=(int)%s(%s, %i);\"%(index, var, index2, self.input_dim-1) for index, var, index2 in zip(['ii', 'jj'], ['X2', 'Z2'], ['i', 'j'])]\r\n precompute_list += c_define_output_indices\r\n reverse_arg_string = \", \".join(reverse_arg_list)\r\n arg_string = \", \".join(arg_list)\r\n precompute_string = \"\\n\".join(precompute_list)\r\n\r\n # Code to compute argments string needed when only X is provided.\r\n X_arg_string = re.sub('Z','X',arg_string)\r\n # Code to compute argument string when only diagonal is required.\r\n diag_arg_string = re.sub('int jj','//int jj',X_arg_string)\r\n diag_arg_string = re.sub('j','i',diag_arg_string)\r\n if precompute_string == '':\r\n # if it's not multioutput, the precompute strings are set to zero\r\n diag_precompute_string = ''\r\n diag_precompute_replace = ''\r\n else:\r\n # for multioutput we need to extract the index of the output form the input.\r\n diag_precompute_string = precompute_list[0]\r\n diag_precompute_replace = precompute_list[1]\r\n \r\n\r\n # Here's the code to do the looping for K\r\n self._K_code =\\\r\n \"\"\"\r\n // _K_code\r\n // Code for computing the covariance function.\r\n int i;\r\n int j;\r\n int N = target_array->dimensions[0];\r\n int num_inducing = target_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N;i++){\r\n for (j=0;j<num_inducing;j++){\r\n%s\r\n //target[i*num_inducing+j] = \r\n TARGET2(i, j) += k(%s);\r\n }\r\n }\r\n %s\r\n \"\"\"%(precompute_string,arg_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n\r\n self._K_code_X = \"\"\"\r\n // _K_code_X\r\n // Code for computing the covariance function.\r\n int i;\r\n int j;\r\n int N = target_array->dimensions[0];\r\n int num_inducing = target_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N;i++){\r\n %s // int ii=(int)X2(i, 1);\r\n TARGET2(i, i) += k(%s);\r\n for (j=0;j<i;j++){\r\n %s //int jj=(int)X2(j, 1);\r\n double kval = k(%s); //double kval = k(X2(i, 0), shared_lengthscale, LENGTHSCALE1(ii), SCALE1(ii));\r\n TARGET2(i, j) += kval;\r\n TARGET2(j, i) += kval;\r\n }\r\n }\r\n /*%s*/\r\n \"\"\"%(diag_precompute_string, diag_arg_string, re.sub('Z2', 'X2', diag_precompute_replace), X_arg_string,str(self._sp_k)) #adding a string representation forces recompile when needed\r\n\r\n # Code to do the looping for Kdiag\r\n self._Kdiag_code =\\\r\n \"\"\"\r\n // _Kdiag_code\r\n // Code for computing diagonal of covariance function.\r\n int i;\r\n int N = target_array->dimensions[0];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for\r\n for (i=0;i<N;i++){\r\n %s\r\n //target[i] =\r\n TARGET1(i)=k(%s);\r\n }\r\n %s\r\n \"\"\"%(diag_precompute_string,diag_arg_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n\r\n # Code to compute gradients\r\n grad_func_list = []\r\n if self.output_dim>1:\r\n grad_func_list += c_define_output_indices\r\n grad_func_list += [' '*16 + 'TARGET1(%i+ii) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, arg_string) for i, theta in enumerate(self._sp_theta_i)]\r\n grad_func_list += [' '*16 + 'TARGET1(%i+jj) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, reverse_arg_string) for i, theta in enumerate(self._sp_theta_i)]\r\n grad_func_list += ([' '*16 + 'TARGET1(%i) += PARTIAL2(i, j)*dk_d%s(%s);'%(i,theta.name,arg_string) for i,theta in enumerate(self._sp_theta)])\r\n grad_func_string = '\\n'.join(grad_func_list) \r\n\r\n self._dK_dtheta_code =\\\r\n \"\"\"\r\n // _dK_dtheta_code\r\n // Code for computing gradient of covariance with respect to parameters.\r\n int i;\r\n int j;\r\n int N = partial_array->dimensions[0];\r\n int num_inducing = partial_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N;i++){\r\n for (j=0;j<num_inducing;j++){\r\n%s\r\n }\r\n }\r\n %s\r\n \"\"\"%(grad_func_string,\"/*\"+str(self._sp_k)+\"*/\") # adding a string representation forces recompile when needed\r\n\r\n\r\n # Code to compute gradients for Kdiag TODO: needs clean up\r\n diag_grad_func_string = re.sub('Z','X',grad_func_string,count=0)\r\n diag_grad_func_string = re.sub('int jj','//int jj',diag_grad_func_string)\r\n diag_grad_func_string = re.sub('j','i',diag_grad_func_string)\r\n diag_grad_func_string = re.sub('PARTIAL2\\(i, i\\)','PARTIAL1(i)',diag_grad_func_string)\r\n self._dKdiag_dtheta_code =\\\r\n \"\"\"\r\n // _dKdiag_dtheta_code\r\n // Code for computing gradient of diagonal with respect to parameters.\r\n int i;\r\n int N = partial_array->dimensions[0];\r\n int input_dim = X_array->dimensions[1];\r\n for (i=0;i<N;i++){\r\n %s\r\n }\r\n %s\r\n \"\"\"%(diag_grad_func_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n\r\n # Code for gradients wrt X, TODO: may need to deal with special case where one input is actually an output.\r\n gradX_func_list = []\r\n if self.output_dim>1:\r\n gradX_func_list += c_define_output_indices\r\n gradX_func_list += [\"TARGET2(i, %i) += PARTIAL2(i, j)*dk_dx_%i(%s);\"%(q,q,arg_string) for q in range(self._real_input_dim)]\r\n gradX_func_string = \"\\n\".join(gradX_func_list)\r\n\r\n self._dK_dX_code = \\\r\n \"\"\"\r\n // _dK_dX_code\r\n // Code for computing gradient of covariance with respect to inputs.\r\n int i;\r\n int j;\r\n int N = partial_array->dimensions[0];\r\n int num_inducing = partial_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N; i++){\r\n for (j=0; j<num_inducing; j++){\r\n %s\r\n }\r\n }\r\n %s\r\n \"\"\"%(gradX_func_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n \r\n\r\n diag_gradX_func_string = re.sub('Z','X',gradX_func_string,count=0)\r\n diag_gradX_func_string = re.sub('int jj','//int jj',diag_gradX_func_string)\r\n diag_gradX_func_string = re.sub('j','i',diag_gradX_func_string)\r\n diag_gradX_func_string = re.sub('PARTIAL2\\(i, i\\)','2*PARTIAL1(i)',diag_gradX_func_string)\r\n\r\n # Code for gradients of Kdiag wrt X\r\n self._dKdiag_dX_code= \\\r\n \"\"\"\r\n // _dKdiag_dX_code\r\n // Code for computing gradient of diagonal with respect to inputs.\r\n int N = partial_array->dimensions[0];\r\n int input_dim = X_array->dimensions[1];\r\n for (int i=0;i<N; i++){\r\n %s\r\n }\r\n %s\r\n \"\"\"%(diag_gradX_func_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a\r\n # string representation forces recompile when needed Get rid\r\n # of Zs in argument for diagonal. TODO: Why wasn't\r\n # diag_func_string called here? Need to check that.\r\n #self._dKdiag_dX_code = self._dKdiag_dX_code.replace('Z[j', 'X[i')\r\n\r\n # Code to use when only X is provided. \r\n self._dK_dtheta_code_X = self._dK_dtheta_code.replace('Z[', 'X[')\r\n self._dK_dX_code_X = self._dK_dX_code.replace('Z[', 'X[').replace('+= PARTIAL2(', '+= 2*PARTIAL2(') \r\n self._dK_dtheta_code_X = self._dK_dtheta_code_X.replace('Z2(', 'X2(')\r\n self._dK_dX_code_X = self._dK_dX_code_X.replace('Z2(', 'X2(')\r\n\r\n\r\n #TODO: insert multiple functions here via string manipulation\r\n #TODO: similar functions for psi_stats\r","def numerize():\n pass","def numeric(*args):","def generate_cpp():\n cpp_file = AUTOGEN_WARNING\n cpp_file += \"// Implements basic nuclear data functions.\\n\"\n cpp_file += \"#ifndef PYNE_IS_AMALGAMATED\\n\"\n cpp_file += '#include \"atomic_data.h\"\\n'\n cpp_file += '#include \"nucname.h\"\\n'\n cpp_file += \"#endif\\n\"\n cpp_file += \" \\n\"\n cpp_file += \"void pyne::_load_atomic_mass_map_memory() { \\n\"\n cpp_file += \" // header version of atomic weight table data \\n\"\n cpp_file += \" //see if the data table is already loaded\\n\"\n cpp_file += \" if(!atomic_mass_map.empty()) {\\n\"\n cpp_file += \" return;\\n\"\n cpp_file += \" } else { \\n\"\n cpp_file += \" _insert_atomic_mass_map();\\n\"\n cpp_file += \" }\\n\"\n cpp_file += \" //see if the data table is already loaded\\n\"\n cpp_file += \" if(!natural_abund_map.empty()) {\\n\"\n cpp_file += \" return;\\n\"\n cpp_file += \" } else { \\n\"\n cpp_file += \" _insert_abund_map();\\n\"\n cpp_file += \" }\\n\"\n cpp_file += \" // calculate the atomic_masses of the elements \\n\"\n cpp_file += \" std::map<int,double> :: iterator it;\\n\"\n cpp_file += \" \\n\"\n cpp_file += \" for (int z = 1; z <= 92 ; z++) {\\n\"\n cpp_file += \" // loop through the natural abundance map\\n\"\n cpp_file += \" double element_atomic_weight = 0.0;\\n\"\n cpp_file += \" for (it = natural_abund_map.begin(); it != natural_abund_map.end() ; ++it){\\n\"\n cpp_file += \" // if the atomic number of the abudance matches the\\n\"\n cpp_file += \" // that of index\\n\"\n cpp_file += \" if(pyne::nucname::znum(it->first) == z) {\\n\"\n cpp_file += \" // take atomic abundance and multiply by mass\\n\"\n cpp_file += (\n \" // to get the mass of that nuclide / 100 since abundance is in %\\n\"\n )\n cpp_file += \" element_atomic_weight += (it->second*atomic_mass_map[it->first]/100.0);\\n\"\n cpp_file += \" }\\n\"\n cpp_file += \" }\\n\"\n cpp_file += \" // insert the abundance of the element into the list\\n\"\n cpp_file += \" atomic_mass_map[z*10000000] = element_atomic_weight;\\n\"\n cpp_file += \" }\\n\"\n cpp_file += \"}\\n\"\n cpp_file += \"\\n\\n\"\n cpp_file += \"void pyne::_insert_atomic_mass_map() { \\n\"\n cpp_file += generate_atomic_mass()\n cpp_file += \"}\\n\"\n cpp_file += \"\\n\\n\"\n cpp_file += \"void pyne::_insert_abund_map() { \\n\"\n cpp_file += generate_abundances()\n cpp_file += \"}\\n\"\n return cpp_file","def generate():","def genCode(self):\n # Init variables and environment.\n if 'Sys' in self.inputs:\n self.cg_bootstrap_sys()\n\n for ns, vm_code in self.inputs.items():\n input = Parser(vm_code).parse()\n self.ns = ns\n\n if input['errors']:\n # No meaningful output can be generated.\n # Print errors to stderr and return empty string.\n print(\"ERRORS\", file=sys.stderr)\n for err in input['errors']:\n print(\"Line {}: {}\".format(err.line, err.msg))\n return f\"// Encountered errors parsing {filename}\"\n\n # Translate input.\n self.asm(f\"// Input file: {ns}\")\n for cmd in input['commands']:\n # Print original VM command as a comment.\n self.asm('// ' + cmd.src)\n self.cg(cmd)\n self.asm(f\"// End of input file: {ns}\")\n\n # Add the stop loop.\n self.cg_stop()\n\n return '\\n'.join(self.text)","def curve_number(self):","def v_numeric(self, **kwargs):\n self.system.groups['StaticGen'].set(src='u', idx=self.gen.v, attr='v', value=0)","def getNumber():","def gen_code():\n return ''.join([random.choice(string.ascii_uppercase + string.digits) for _ in range(10)])","def generate(self):\n tempSn_1 = self.sn_1\n self.sn_1 = (self.an_2*self.sn_2 + self.an_1*self.sn_1) % self.mod\n self.sn_2 = tempSn_1\n return self.sn_1 / self.mod","def main():\n result = 0\n for n in range(1, 1001):\n result += n**n\n\n result = str(result)\n answer = result[len(result)-10::]\n\n print \"answer: \" + answer","def generate_swift_code(self, num):\n swift_code = []\n for _ in range(num):\n swift_code.append(self.fake.swift())\n return swift_code","def gencode(self):\n\n fullcode = self.code_cfg\n variables = codeconfig_getvars(fullcode)\n if len(variables) > 0:\n variables.sort(key=lambda x: len(x), reverse=True)\n for va in variables:\n if eval(\"self.\" + va[1:]) is None or eval(\"self.\" + va[1:]) == \"\":\n warnings.warn(\"Inserting None for \" + va, UserWarning)\n fullcode = fullcode.replace(va, str(eval(\"self.\" + va[1:])))\n # testing for sintax errors\n #compile(fullcode, \"<Test ModelCall Code>\\n\" + fullcode, 'exec')\n tmpfile = os.path.join(gettempdir(), \"TestModelCallCode.\" + self.complexity + \".py\")\n with open(tmpfile, \"w\") as f: f.write(fullcode)\n compile(fullcode, tmpfile, 'exec')\n return fullcode","def code():","def test_numbers(self):\n \n result = gen_expansion(sym.pi, 2)\n self.assertEqual(result, '14')\n result = gen_expansion(sym.exp(1), 2)\n self.assertEqual(result, '72')","def evaluate(self) -> int:","def _pettifor_numbers():\n return { \"Li\": 0.45,\n \"Be\": 1.5,\n \"B\": 2.0,\n \"C\": 2.5,\n \"N\": 3.0, \n \"O\": 3.5,\n \"F\": 4.0,\n \n \"Na\": 0.4,\n \"Mg\": 1.28,\n \"Al\": 1.66,\n \"Si\": 1.92,\n \"P\": 2.18,\n \"S\": 2.44,\n \"Cl\": 2.70,\n \n \"K\": 0.35,\n \"Ca\": 0.60,\n \"Sc\": 0.74,\n \"Ti\": 0.79,\n \"V\": 0.84,\n \"Cr\": 0.89,\n \"Mn\": 0.94,\n \"Fe\": 0.99,\n \"Co\": 1.04,\n \"Ni\": 1.09,\n \"Cu\": 1.20,\n \"Zn\": 1.44,\n \"Ga\": 1.68,\n \"Ge\": 1.92,\n \"As\": 2.16,\n \"Se\": 2.40,\n \"Br\": 2.64,\n\n \"Rb\": 0.30,\n \"Sr\": 0.55,\n \"Y\": 0.70,\n \"Zr\": 0.76,\n \"Nb\": 0.82,\n \"Mo\": 0.88,\n \"Tc\": 0.94,\n \"Ru\": 1.00,\n \"Rh\": 1.06,\n \"Pd\": 1.12,\n \"Ag\": 1.18,\n \"Cd\": 1.36,\n \"In\": 1.60,\n \"Sn\": 1.84,\n \"Sb\": 2.08,\n \"Te\": 2.32,\n \"I\": 2.56,\n \n \"Cs\": 0.25,\n \"Ba\": 0.50,\n \"La\": 0.748,\n \"Hf\": 0.775,\n \"Ta\": 0.83,\n \"W\": 0.885,\n \"Re\": 0.94,\n \"Os\": 0.995,\n \"Ir\": 1.05,\n \"Pt\": 1.105,\n \"Au\": 1.16,\n \"Hg\": 1.32,\n \"Tl\": 1.56,\n \"Pb\": 1.80,\n \"Bi\": 2.04,\n \"Po\": 2.28, \n \"At\": 2.52 }","def Mo96(self,dc,nu):\n return 1. + (nu**2.-1.)/dc","def _generate_code_blocks(self):\n\n printer = self._generate_pydy_c_printer()()\n\n self.code_blocks = {}\n\n lines = []\n for i, input_arg in enumerate(self.arguments):\n lines.append('double input_{}[{}],'.format(i, len(input_arg)))\n self.code_blocks['input_args'] = wrap_and_indent(lines, 14)\n\n lines = []\n for i, output_arg in enumerate(self.matrices):\n nr, nc = output_arg.shape\n lines.append('double output_{}[{}],'.format(i, nr * nc))\n self.code_blocks['output_args'] = \\\n wrap_and_indent(lines, 14)[:-1] # remove last comma\n\n lines = []\n for i, (input_arg, explan) in enumerate(zip(self.arguments,\n self.comma_lists())):\n lines.append('input_{}[{}] : [{}]'.format(i, len(input_arg),\n explan))\n self.code_blocks['input_docstring'] = wrap_and_indent(lines, 0)\n\n lines = []\n for var, expr in self.subexprs:\n var_str = printer.doprint(var)\n expr_str = printer.doprint(expr)\n lines.append('double {} = {};'.format(var_str, expr_str))\n self.code_blocks['subexprs'] = wrap_and_indent(lines)\n\n outputs = ''\n for i, output in enumerate(self.simplified_matrices):\n nr, nc = output.shape\n lhs = sm.MatrixSymbol('output_{}'.format(i), nr, nc)\n try:\n code_str = printer.doprint(output, lhs)\n except AttributeError:\n # The above fails in SymPy 0.7.4.1 because Matrix printing\n # isn't supported.\n code_lines = []\n for j, element in enumerate(output):\n assignment = 'output_{}[{}]'.format(i, j)\n code_lines.append(printer.doprint(element, assignment))\n code_str = '\\n'.join(code_lines)\n outputs += wrap_and_indent(code_str.split('\\n'))\n if i != len(self.simplified_matrices) - 1:\n outputs += '\\n\\n' # space between each output\n\n self.code_blocks['outputs'] = outputs","def main():\n for i in range(11):\n i = i / 10\n print('L * 1000', i, L(i) * 1000)","def data_generation():\n num1 = random.randint(1, 100)\n num2 = random.randint(1, 100)\n correct_answer = math.gcd(num1, num2)\n expression = f'{num1} {num2}'\n return expression, str(correct_answer)","def code_str(self, fn_name):\n code = CodeWriter()\n code.wl(\"def \" + fn_name + \"(y):\")\n code.inc_indent()\n if self.m == 1:\n code.wl(\"x = \" + str(self._a) + \" * y + \" + str(self._b))\n else:\n code.wl(\"a = np.\" + self._a.__repr__())\n code.wl(\"b = np.\" + self._b.__repr__())\n code.wl(\"x = np.dot(a, y) + b\")\n poly_eval_code = self._unit_simplex_polynomial.code_str(\"temp\")\n poly_eval_code = poly_eval_code.split('\\n')[1:]\n poly_eval_code = \"\\n\".join(poly_eval_code)\n code.verbatim(poly_eval_code)\n code.dec_indent()\n return code.code","def generate(bits):\r\n raise NotImplementedError()","def _generate_code(x, functional):\n\n printer = sympy.printing.lambdarepr.PythonCodePrinter()\n\n code = \"def evaluate(values, solution):\\n\"\n code += \"\\tfor k in range(len(values)):\\n\"\n code += \"\\t\\t\" + \", \".join(str(state) for state in x) + \" = solution[k]\\n\"\n code += f\"\\t\\tvalues[k] = {printer.doprint(functional.evalf())}\\n\"\n return code","def generate(self):","def code() -> str:\n return \"\"\"\n G91 G17\n G0 Y10 X-10\n G0 Y0 X-5\n G0 Y5 X0\n G0 Y0 X5\n G0 Y0 X-5\n G0 Y-5 X0\n G3 Y-5 X5 J0 I5\n G0 Y0 X5\n G0 Y5 X0\n G3 Y5 X-5 J0 I-5\n G0 Y-5 X0\n G0 Y-10 X10\n G0 Y0 X-5\n G0 Y-15 X-15\n G0 Y0 X5\n G0 Y5 X0\n G0 Y0 X-5\n G0 Y-5 X0\n G0 Y5 X0\n G2 Y5 X5 J0 I5\n G0 Y0 X5\n G0 Y-5 X0\n G2 Y-5 X-5 J0 I-5\n G0 Y5 X0\n G0 Y10 X10\n G0 Y0 X-30\n G3 Y0 X-10 J0 I-5\n G3 Y0 X10 J0 I5\n\n G0 Y0 X5\n G3 Y5 X5 J5 I0\n G3 Y10 X-10 J0 I-10\n G3 Y-5 X-5 J-5 I0\n G0 Y-5 X0\n\n G0 Y5 X0\n G3 Y5 X-5 J0 I-5\n G3 Y-10 X-10 J-10 I0\n G3 Y-5 X5 J0 I5\n G0 Y0 X5\n\n G0 Y0 X-5\n G3 Y-5 X-5 J-5 I0\n G3 Y-10 X10 J0 I10\n G3 Y5 X5 J5 I0\n G0 Y5 X0\n\n G0 Y-5 X0\n G3 Y-5 X5 J0 I5\n G3 Y10 X10 J10 I0\n G3 Y5 X-5 J0 I-5\n G0 Y0 X-5\n \"\"\"","def calculate(self):\n\n outs = map(str, map(self.translate, self.nums))\n result = \"\\n\".join(outs)\n\n return str(result)","def test_generate_nb(self):\n pass","def __math__(inputs: list) -> str:\n # TODO: Find new way of indicating that a variable should be used instead of a static value.\n\n out = \"\"\n if len(inputs) < 2:\n return None # TODO: create error and throw that instead\n fname, func = inspect.getmembers(math, inspect.isbuiltin)[inputs[0]]\n out += fname + \"(\"\n nvars = MachineInterface.__math_doc_nvars__(func.__doc__)\n if nvars == 1:\n out += str(inputs[1]) + \",\"\n else:\n for i in range(1, nvars):\n out += str(inputs[i % len(inputs)]) + \",\"\n\n return out[:-1] + \")\"\n # b = func.__doc__\n # print(dir(func))\n # print(b)\n # print(dir(b))\n # print(inspect.signature(b)","def code_format(self):\n return \"^\\\\d{%s}$\" % self._digits","def make_g_number():\n return fake.bothify(text='??#########')","def y(self) -> int:","def GenerateCode(self):\n print \"Generating code...\"\n for type in self.getObjectTypes():\n generator = __import__(\"codegen.Cpp\" + type, globals(), locals(), [''])\n print \"Generating code for objects of type: %s\" % type\n generator.GenerateCode(self)","def function(self):\n return self.generator.module.neumannx","def random_num(self):\r\n self.generate_n1()\r\n self.generate_n2()\r\n self.generate_n3()\r\n self.generate_n4()\r\n random_number = str(self.n_1decimal)+str(self.n_2decimal)+str(self.n_3decimal)+str(self.n_4decimal)\r\n print int(random_number)","def generate_new_code():\n code = ''.join(random.choice(string.digits) for i in range(6))\n return code","def GenerateNormalExpression(n):\n if int(n) != n or n < 1:\n return None\n return '+'.join(['a[%d]' % ii for ii in range(n)])","def make_code(self, datasetname):\n try:\n if(datasetname):\n for i in range(1, len(self.extract()) + 1):\n self.formated = datasetname + \"%03d\" % (i,)\n yield self.formated \n except:\n raise","def NACA4digitsSym(self):\n self.ytu = self.NacaEquation(self.xu,self.t)\n self.ytl = -self.NacaEquation(self.xl,self.t)\n # Done for estitic reasons\n self.yu = self.ytu \n self.yl = self.ytl\n self.z = np.concatenate((self.yu, np.flip(self.yl)))\n if self.plot:\n plt.figure(self.name)\n plt.title(self.name)\n plt.plot(self.xu,self.yu)\n plt.plot(self.xl,self.yl)\n plt.axis('equal')","def generate(self):\r\n raise NotImplementedError","def generate_code(model, dataloader, code_length, device):\n model.eval()\n with torch.no_grad():\n N = len(dataloader.dataset)\n code = torch.zeros([N, code_length])\n for data, _, index in dataloader:\n data = data.to(device)\n hash_code = model(data)\n code[index, :] = hash_code.sign().cpu()\n\n model.train()\n return code","def gen_amounts(no_cultures):\n # Init amounts\n C = 0.01\n N = 1.0\n S = 0.0\n init_amounts = np.array([C, N, S]*no_cultures)\n return init_amounts","def calculate_output(self):","def Codingfunc(N,L): #Coding:[N:number of repetitions, L:length of single/multiple sequence]\r\n C=0 #int variable containing code number\r\n if N==1:\r\n C=L-1\r\n else:\r\n C=-(L-1)*16-(N-1)\r\n #print(\"C =\",C,end=' ')\r\n \r\n return struct.pack('b',C)","def calculate(self):","def generate_code(spn_id, spn, meta_types, floating_data_type):\r\n\r\n # make sure we have ids\r\n assign_ids(spn)\r\n\r\n # fill method body according to SPN structure\r\n method_body = generate_method_body(spn, spn, floating_data_type, 0)\r\n\r\n # build parameters used in generated c++ function\r\n method_params = []\r\n passed_params = []\r\n for i, type in enumerate(meta_types):\r\n if type == MetaType.DISCRETE:\r\n method_params += [f'vector <int> possibleValues{i}', f'int nullValueIdx{i}']\r\n passed_params += [f'py::arg(\"possibleValues{i}\")', f'py::arg(\"nullValueIdx{i}\")']\r\n elif type == MetaType.REAL:\r\n method_params += [f'bool inverse{i}', f'bool leftMinusInf{i}', f'float leftCondition{i}',\r\n f'bool rightMinusInf{i}', f'float rightCondition{i}', f'bool leftIncluded{i}',\r\n f'bool rightIncluded{i}', f'float nullValue{i}']\r\n passed_params += [f'py::arg(\"inverse{i}\")', f'py::arg(\"leftMinusInf{i}\")', f'py::arg(\"leftCondition{i}\")',\r\n f'py::arg(\"rightMinusInf{i}\")', f'py::arg(\"rightCondition{i}\")',\r\n f'py::arg(\"leftIncluded{i}\")', f'py::arg(\"rightIncluded{i}\")', f'py::arg(\"nullValue{i}\")']\r\n\r\n value_dictionary = {\r\n 'spn_id': spn_id,\r\n 'method_body': method_body,\r\n 'method_params': ', '.join(method_params),\r\n 'node_count': get_number_of_nodes(spn),\r\n 'passed_params': ', '.join(passed_params),\r\n 'floating_data_type': floating_data_type\r\n }\r\n generated_method = replace_template(TemplatePath.METHOD_MASTER, value_dictionary, 0)\r\n registrate_method = replace_template(TemplatePath.REGISTRATION_MASTER, value_dictionary, 0)\r\n\r\n return generated_method, registrate_method","def problem_48():\n\n return int(str(sum(x**x for x in range(1, 1001)))[-10:])","def function(self):\n return self.generator.module.neumannz","def valor(self):\n nbits = len(self.gens)\n dec = int(self.gens,2)\n real = self.min+dec*((self.max-self.min)/(math.pow(2,nbits)-1))\n return real","def gen_code(self, compile_unit):\n self.builder = irutils.Builder()\n self.ir_var_map = {}\n self.logger.debug(\"Generating IR-code\")\n self.debug_db = debuginfo.DebugDb()\n ir_mod = ir.Module(\"main\", debug_db=self.debug_db)\n self.builder.module = ir_mod\n\n # Split declaration into functions and variables:\n functions = []\n variables = []\n for declaration in compile_unit.declarations:\n assert isinstance(declaration, declarations.CDeclaration)\n\n if isinstance(\n declaration,\n (declarations.Typedef, declarations.EnumConstantDeclaration),\n ):\n pass\n elif isinstance(declaration, declarations.FunctionDeclaration):\n functions.append(declaration)\n elif isinstance(declaration, declarations.VariableDeclaration):\n variables.append(declaration)\n else: # pragma: no cover\n raise NotImplementedError(str(declaration))\n\n # Generate code:\n for variable in variables:\n self.gen_global_variable(variable)\n\n for function in functions:\n self.create_function(function)\n\n for function in functions:\n self.gen_function(function)\n\n self.logger.info(\"Finished IR-code generation\")\n return ir_mod","def NumericString_ (typecode, value) :\r\n if typecode == 'f' :\r\n return formatHelp_(\"%#.7G\", value)\r\n \r\n elif typecode == 'd' :\r\n return formatHelp_(\"%#.16G\", value)\r\n \r\n elif typecode == 'F' :\r\n front = '('+formatHelp_(\"%#.7G\", value.real, strip_all_zeros=True)\r\n if value.imag==0 :\r\n front += \"+0j)\"\r\n else :\r\n front += formatHelp_(\"%+#.7G\", value.imag, strip_all_zeros=True)+\"j)\"\r\n return front\r\n \r\n elif typecode == 'D' :\r\n front = '('+formatHelp_(\"%#.16G\", value.real, strip_all_zeros=True)\r\n if value.imag==0 :\r\n front += \"+0j)\"\r\n else :\r\n front += formatHelp_(\"%+#.16G\", value.imag, strip_all_zeros=True)+\"j)\"\r\n return front\r\n \r\n else :\r\n return str(value)","def calculate_exponent():\n pass","def numer(self, a):\n raise NotImplementedError","def genRate(self):\n\n # We need to compute normEsquared before we can compute the generation\n # rate\n normEsq = self.get_scalar_quantity('normEsquared')\n # Prefactor for generation rate. Note we gotta convert from m^3 to\n # cm^3, hence 1e6 factor\n fact = consts.epsilon_0 / (consts.hbar * 1e6)\n gvec = np.zeros_like(normEsq)\n # Main loop to compute generation in each layer\n freq = self.conf[('Simulation', 'params', 'frequency')]\n for name, layer in self.layers.items():\n self.log.debug('LAYER: %s', name)\n self.log.debug('LAYER T: %f', layer.thickness)\n self.log.debug('START: %f', layer.start)\n self.log.debug('END: %f', layer.end)\n # Use the layer object to get the nk matrix with correct material\n # geometry\n nmat, kmat = layer.get_nk_matrix(freq, self.X, self.Y)\n gvec[layer.get_slice(self.Z)] = fact * nmat * kmat * normEsq[layer.get_slice(self.Z)]\n # gvec[layer.get_slice()] = nmat * kmat * normEsq[layer.get_slice(self.Z)]\n self.extend_data('genRate', gvec)\n return gvec","def _rawprng(self):\n self.p += 1 \n if self.p >= self.o:\n\t\t\tself.p = 0\n t = 1768863 * self.s[self.p] + self.c * 2.3283064365386963e-10\n self.c = int(t) | 0\n self.s[self.p] = t - self.c\n return self.s[self.p]","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def ccode(self):\n from devito.ir.iet.visitors import CGen\n return CGen().visit(self)","def get_fitness_function_c_code(self):\n s = \"\"\"FLOAT fitness_function(FLOAT phi, FLOAT chi, FLOAT omega)\n {\n FLOAT fitness = absolute(phi);\n return fitness;\n }\n \"\"\" \n return s","def get_fitness_function_c_code(self):\n s = \"\"\"FLOAT fitness_function(FLOAT phi, FLOAT chi, FLOAT omega)\n {\n FLOAT fitness = absolute(phi);\n return fitness;\n }\n \"\"\" \n return s","def create_code():\n\n code = [0, 0, 0, 0]\n\n for i in range(4):\n value = random.randint(1, 8) # 8 possible digits\n while value in code:\n value = random.randint(1, 8) # 8 possible digits\n code[i] = value\n \n #print(code)\n return code","def function(self):\n return self.generator.module.neumann","def genus(self):\n return 1 - self.euler_characteristic() // 2","def value(self):\n try: return 10.**(self._value)\n except AttributeError: raise GAError, 'gene not initialized'","def gm2code(arr, info):\n return (arr / info.pboxsize + 0.5)# * 0.999783599","def generate_code_implementation(name, code, comment=None):\n k = code.dimension()\n cs, _p = code.standard_form()\n info = {\n 'name': name,\n 'n': code.length(),\n 'k': k,\n 'generator': [bools_to_binvec(row) for row in cs.systematic_generator_matrix()],\n 'generator_bools': cs.systematic_generator_matrix(),\n 'parity_matrix': [bools_to_binvec(row) for row in cs.parity_check_matrix()],\n \"comment\": comment,\n }\n\n max_error = code.decoder().maximum_error_weight()\n\n syndrome_map = {}\n for (he, error) in cs.decoder().syndrome_table().items():\n syndrome_map[ZZ(list(he), base=2)] = bools_to_binvec(error)\n\n info['syndrome_map'] = syndrome_map\n info['syndrome_map_itemlen'] = len(list(syndrome_map.values())[0])\n\n assert max(syndrome_map) < 2**64, \"sydrome map too big!\"\n \n info['info_set'] = cs.information_set()\n\n testcases = []\n if 'might-error' in cs.decoder().decoder_type():\n max_error -= 3\n for _ in range(20):\n randvec = random_vector(GF(2), code.length())\n codeword = cs.decode_to_code(randvec)\n testcase = {\n 'randvec': randvec,\n 'codeword': codeword,\n }\n testcases.append(testcase)\n\n info['testcases'] = testcases\n\n with open('syndrome_code_implementation.rs.j2', 'r') as templatefile:\n template = ENVIRONMENT.from_string(templatefile.read())\n with open('{name}/{name}_{n}_{k}.rs'.format(name=name.lower(),\n n=code.length(), k=k),\n 'w') as outputfile:\n outputfile.write(template.render(**info))\n\n rendered_codes[name].append((code.length(), code.dimension()))","def generate(self):\n return self.gen.generate()","def typecode (self) :\r\n return self.numeric_typecode","def power_gen(k):\n if k == 0:\n return constant\n if k == 1:\n return identity\n @natural_input\n def power_k(n):\n return n ** k\n return power_k","def _numeric_jacobian(self):\n if self.__numeric_jacobian is None:\n self.__numeric_jacobian = self._lambdify(self._symbolic_jacobian)\n return self.__numeric_jacobian","def make_anonymous_factorial():\n return 'YOUR_EXPRESSION_HERE'","def make_anonymous_factorial():\n return 'YOUR_EXPRESSION_HERE'","def make_anonymous_factorial():\n return 'YOUR_EXPRESSION_HERE'","def make_anonymous_factorial():\n return 'YOUR_EXPRESSION_HERE'","def numer(self, a):\n return a","def generateCodeWithoutIndices(self, codeGenerator):\n return self.variable.generateCode(codeGenerator)","def generate(self):\n pass","def n():\n # For documentation purposes","def generate(self):\n start = self.nu_idx\n stop = start + self.score\n return self.orig_nu[start:stop]","def fortran_functions(self) -> str:\n fun_name = f'{self.f_prefix}_{self.name}_to_int_'\n result = f'integer function {fun_name}(flags)\\n'\n result += ' implicit none\\n'\n result += '\\n'\n result += f' class({self.f_prefix}_{self.name}), intent(in) :: flags\\n'\n result += ' integer :: ret_val\\n'\n result += '\\n'\n result += ' ret_val = 0\\n'\n for i, value in enumerate(self.values):\n result += f\" if (flags%{value}) ret_val = ret_val + {1 << i}\\n\"\n result += f' {fun_name} = ret_val\\n'\n result += f'end function {fun_name}\\n'\n return indent(result, 4*' ')","def generate(self):\n pass","def generate(self):\n pass"],"string":"[\n \"def code(self):\\n if not self._code:\\n filename = '<fluxtools function %s>' % self.tag\\n self._code = compile(self.math, filename, mode='eval')\\n return self._code\",\n \"def _get_random_number_code(self):\\r\\n return \\\"str(random.randint(0, 1e9))\\\"\",\n \"def number(self):\",\n \"def gen_code(self, filename, func_name):\\n\\n assert self.bits is not None\\n\\n vd_list = []\\n n_vars = 0\\n for tree in self.trees:\\n vd_list.append(tree.gen_code(n_vars))\\n n_vars += len(vd_list[-1])\\n\\n # checks the type by the suffix\\n\\n is_v = filename.split(\\\".\\\")[-1] == \\\"v\\\"\\n\\n assert self.inputs\\n\\n f = open(filename, \\\"w\\\")\\n\\n i_bits = np.sum(self.bits[:-1])\\n o_bits = self.bits[-1]\\n o_sign = self.is_neg[-1]\\n\\n if is_v:\\n f.write(\\\"module {}(input [{}:0] i, output [{}:0] o);\\\\n\\\".format(\\n func_name, i_bits-1, o_bits-1))\\n else:\\n f.write(\\\"#include<ac_int.h>\\\\n\\\\n\\\")\\n f.write(\\\"void {}(ac_int<{},false> i, ac_int<{},{}> &o)\\\\n\\\".format(\\n func_name, i_bits, o_bits, o_sign))\\n f.write(\\\"{\\\\n\\\")\\n\\n\\n # write function headline\\n s_in_line = []\\n\\n i_bits = self.bits[0]\\n i_sign = self.is_neg[0]\\n\\n if is_v:\\n i_datatype = \\\" wire {}[{}:0] \\\".format(\\n \\\"signed \\\" if i_sign else \\\"\\\", i_bits-1)\\n else:\\n i_datatype = \\\" ac_int<{},{}> \\\".format(i_bits, i_sign)\\n\\n len_s = len(i_datatype)\\n\\n for i in range(self.inputs):\\n if is_v:\\n s = (\\n \\\"i_\\\" + str(i) + \\\" = \\\" + \\\"i[\\\" + str(i_bits*(i+1)-1) + \\\":\\\" +\\n str(i_bits*i) + \\\"]\\\"\\n )\\n else:\\n s = (\\n \\\"i_\\\" + str(i) + \\\" = \\\" + \\\"i.slc<\\\" + str(i_bits) + \\\">(\\\" +\\n str(i_bits*i) + \\\")\\\"\\n )\\n if (\\n len_s + len(s) + 2 > 70 or i_bits != self.bits[i] or\\n i_sign != self.is_neg[i]\\n ):\\n f.write(i_datatype + \\\", \\\".join(s_in_line) + \\\";\\\\n\\\")\\n\\n s_in_line = []\\n if is_v:\\n i_datatype = \\\" wire {}[{}:0] \\\".format(\\n \\\"signed \\\" if i_sign else \\\"\\\", i_bits-1)\\n else:\\n i_datatype = \\\" ac_int<{},{}> \\\".format(i_bits, i_sign)\\n\\n len_s = len(i_datatype)\\n\\n s_in_line.append(s)\\n len_s += len(s) + 2\\n\\n if s_in_line:\\n f.write(i_datatype + \\\", \\\".join(s_in_line) + \\\";\\\\n\\\")\\n\\n if is_v:\\n o_datatype = \\\" wire {}[{}:0] \\\".format(\\n \\\"signed \\\" if o_sign else \\\"\\\", o_bits)\\n else:\\n o_datatype = \\\" ac_int<{},{}> \\\".format(o_bits, o_sign)\\n\\n o_list = []\\n for i in range(len(vd_list)):\\n for v in vd_list[i]:\\n if is_v:\\n f.write(o_datatype + v + \\\" = \\\" + vd_list[i][v] + \\\";\\\\n\\\")\\n else:\\n f.write(o_datatype + v + \\\" = \\\" + vd_list[i][v] + \\\";\\\\n\\\")\\n f.write(\\\"\\\\n\\\")\\n o_list.append(v)\\n\\n assert len(o_list) <= 3\\n\\n if is_v:\\n f.write(\\\" assign \\\")\\n else:\\n f.write(\\\" \\\")\\n\\n if len(o_list) == 1:\\n f.write(\\\"o = \\\" + o_list[0] + \\\";\\\")\\n elif len(o_list) == 2:\\n cond = \\\"( \\\" + o_list[0] + \\\" == \\\" + o_list[1] + \\\" ) \\\"\\n n1 = o_list[0]\\n n0 = \\\"( ( \\\" + \\\" + \\\".join(o_list) + \\\" ) >> 1 )\\\"\\n f.write(\\\"o = \\\" + cond + \\\"? \\\" + n1 + \\\": \\\" + n0)\\n elif len(o_list) == 3:\\n cond = (\\n \\\"( \\\" +\\n \\\"( \\\" + \\\" == \\\".join(o_list[0:2]) + \\\" )?\\\" + o_list[0] + \\\":\\\" +\\n \\\"( \\\" + \\\" == \\\".join(o_list[1:]) + \\\" )?\\\" + o_list[1] + \\\":\\\" +\\n \\\"( \\\" + \\\" == \\\".join([o_list[0], o_list[2]]) + \\\" )?\\\" + o_list[0] +\\n \\\":\\\" + \\\"( \\\" + \\\" < \\\".join(o_list[0:2]) + \\\" ) ?\\\" +\\n \\\"( ( \\\" + \\\" < \\\".join(o_list[1:]) + \\\" ) ?\\\" + o_list[1] + \\\":\\\" +\\n o_list[2] + \\\" ) : \\\" +\\n \\\"( ( \\\" + \\\" < \\\".join([o_list[0], o_list[2]]) + \\\" ) ?\\\" + o_list[0] +\\n \\\":\\\" + o_list[2] + \\\" )\\\"\\n )\\n f.write(\\\"o = \\\" + cond + \\\";\\\\n\\\")\\n if is_v:\\n f.write(\\\"endmodule\\\")\\n else:\\n f.write(\\\"}\\\")\\n\\n f.close()\",\n \"def nr():\\n pass\",\n \"def generation(x, g):\\n return int(x/g)\",\n \"def gen_numeric_literal(self, expr):\\n return self.emit_const(expr.value, expr.typ)\",\n \"def _gen_code(self):\\r\\n #TODO: maybe generate one C function only to save compile time? Also easier to take that as a basis and hand craft other covariances??\\r\\n\\r\\n #generate c functions from sympy objects \\r\\n argument_sequence = self._sp_x+self._sp_z+self._sp_theta\\r\\n code_list = [('k',self._sp_k)]\\r\\n # gradients with respect to covariance input\\r\\n code_list += [('dk_d%s'%x.name,dx) for x,dx in zip(self._sp_x,self._sp_dk_dx)]\\r\\n # gradient with respect to parameters\\r\\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta,self._sp_dk_dtheta)]\\r\\n # gradient with respect to multiple output parameters\\r\\n if self.output_dim > 1:\\r\\n argument_sequence += self._sp_theta_i + self._sp_theta_j\\r\\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta_i,self._sp_dk_dtheta_i)]\\r\\n (foo_c,self._function_code), (foo_h,self._function_header) = \\\\\\r\\n codegen(code_list, \\\"C\\\",'foobar',argument_sequence=argument_sequence)\\r\\n #put the header file where we can find it\\r\\n f = file(os.path.join(tempfile.gettempdir(),'foobar.h'),'w')\\r\\n f.write(self._function_header)\\r\\n f.close()\\r\\n\\r\\n # Substitute any known derivatives which sympy doesn't compute\\r\\n self._function_code = re.sub('DiracDelta\\\\(.+?,.+?\\\\)','0.0',self._function_code)\\r\\n\\r\\n\\r\\n ############################################################\\r\\n # This is the basic argument construction for the C code. #\\r\\n ############################################################\\r\\n \\r\\n arg_list = ([\\\"X2(i, %s)\\\"%x.name[2:] for x in self._sp_x]\\r\\n + [\\\"Z2(j, %s)\\\"%z.name[2:] for z in self._sp_z])\\r\\n\\r\\n # for multiple outputs need to also provide these arguments reversed.\\r\\n if self.output_dim>1:\\r\\n reverse_arg_list = list(arg_list)\\r\\n reverse_arg_list.reverse()\\r\\n\\r\\n # Add in any 'shared' parameters to the list.\\r\\n param_arg_list = [shared_params.name for shared_params in self._sp_theta]\\r\\n arg_list += param_arg_list\\r\\n\\r\\n precompute_list=[]\\r\\n if self.output_dim > 1:\\r\\n reverse_arg_list+=list(param_arg_list)\\r\\n split_param_arg_list = [\\\"%s1(%s)\\\"%(theta.name[:-2].upper(),index) for index in ['ii', 'jj'] for theta in self._sp_theta_i]\\r\\n split_param_reverse_arg_list = [\\\"%s1(%s)\\\"%(theta.name[:-2].upper(),index) for index in ['jj', 'ii'] for theta in self._sp_theta_i]\\r\\n arg_list += split_param_arg_list\\r\\n reverse_arg_list += split_param_reverse_arg_list\\r\\n # Extract the right output indices from the inputs.\\r\\n c_define_output_indices = [' '*16 + \\\"int %s=(int)%s(%s, %i);\\\"%(index, var, index2, self.input_dim-1) for index, var, index2 in zip(['ii', 'jj'], ['X2', 'Z2'], ['i', 'j'])]\\r\\n precompute_list += c_define_output_indices\\r\\n reverse_arg_string = \\\", \\\".join(reverse_arg_list)\\r\\n arg_string = \\\", \\\".join(arg_list)\\r\\n precompute_string = \\\"\\\\n\\\".join(precompute_list)\\r\\n\\r\\n # Code to compute argments string needed when only X is provided.\\r\\n X_arg_string = re.sub('Z','X',arg_string)\\r\\n # Code to compute argument string when only diagonal is required.\\r\\n diag_arg_string = re.sub('int jj','//int jj',X_arg_string)\\r\\n diag_arg_string = re.sub('j','i',diag_arg_string)\\r\\n if precompute_string == '':\\r\\n # if it's not multioutput, the precompute strings are set to zero\\r\\n diag_precompute_string = ''\\r\\n diag_precompute_replace = ''\\r\\n else:\\r\\n # for multioutput we need to extract the index of the output form the input.\\r\\n diag_precompute_string = precompute_list[0]\\r\\n diag_precompute_replace = precompute_list[1]\\r\\n \\r\\n\\r\\n # Here's the code to do the looping for K\\r\\n self._K_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _K_code\\r\\n // Code for computing the covariance function.\\r\\n int i;\\r\\n int j;\\r\\n int N = target_array->dimensions[0];\\r\\n int num_inducing = target_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N;i++){\\r\\n for (j=0;j<num_inducing;j++){\\r\\n%s\\r\\n //target[i*num_inducing+j] = \\r\\n TARGET2(i, j) += k(%s);\\r\\n }\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(precompute_string,arg_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n\\r\\n self._K_code_X = \\\"\\\"\\\"\\r\\n // _K_code_X\\r\\n // Code for computing the covariance function.\\r\\n int i;\\r\\n int j;\\r\\n int N = target_array->dimensions[0];\\r\\n int num_inducing = target_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N;i++){\\r\\n %s // int ii=(int)X2(i, 1);\\r\\n TARGET2(i, i) += k(%s);\\r\\n for (j=0;j<i;j++){\\r\\n %s //int jj=(int)X2(j, 1);\\r\\n double kval = k(%s); //double kval = k(X2(i, 0), shared_lengthscale, LENGTHSCALE1(ii), SCALE1(ii));\\r\\n TARGET2(i, j) += kval;\\r\\n TARGET2(j, i) += kval;\\r\\n }\\r\\n }\\r\\n /*%s*/\\r\\n \\\"\\\"\\\"%(diag_precompute_string, diag_arg_string, re.sub('Z2', 'X2', diag_precompute_replace), X_arg_string,str(self._sp_k)) #adding a string representation forces recompile when needed\\r\\n\\r\\n # Code to do the looping for Kdiag\\r\\n self._Kdiag_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _Kdiag_code\\r\\n // Code for computing diagonal of covariance function.\\r\\n int i;\\r\\n int N = target_array->dimensions[0];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for\\r\\n for (i=0;i<N;i++){\\r\\n %s\\r\\n //target[i] =\\r\\n TARGET1(i)=k(%s);\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(diag_precompute_string,diag_arg_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n\\r\\n # Code to compute gradients\\r\\n grad_func_list = []\\r\\n if self.output_dim>1:\\r\\n grad_func_list += c_define_output_indices\\r\\n grad_func_list += [' '*16 + 'TARGET1(%i+ii) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, arg_string) for i, theta in enumerate(self._sp_theta_i)]\\r\\n grad_func_list += [' '*16 + 'TARGET1(%i+jj) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, reverse_arg_string) for i, theta in enumerate(self._sp_theta_i)]\\r\\n grad_func_list += ([' '*16 + 'TARGET1(%i) += PARTIAL2(i, j)*dk_d%s(%s);'%(i,theta.name,arg_string) for i,theta in enumerate(self._sp_theta)])\\r\\n grad_func_string = '\\\\n'.join(grad_func_list) \\r\\n\\r\\n self._dK_dtheta_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dK_dtheta_code\\r\\n // Code for computing gradient of covariance with respect to parameters.\\r\\n int i;\\r\\n int j;\\r\\n int N = partial_array->dimensions[0];\\r\\n int num_inducing = partial_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N;i++){\\r\\n for (j=0;j<num_inducing;j++){\\r\\n%s\\r\\n }\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(grad_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") # adding a string representation forces recompile when needed\\r\\n\\r\\n\\r\\n # Code to compute gradients for Kdiag TODO: needs clean up\\r\\n diag_grad_func_string = re.sub('Z','X',grad_func_string,count=0)\\r\\n diag_grad_func_string = re.sub('int jj','//int jj',diag_grad_func_string)\\r\\n diag_grad_func_string = re.sub('j','i',diag_grad_func_string)\\r\\n diag_grad_func_string = re.sub('PARTIAL2\\\\(i, i\\\\)','PARTIAL1(i)',diag_grad_func_string)\\r\\n self._dKdiag_dtheta_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dKdiag_dtheta_code\\r\\n // Code for computing gradient of diagonal with respect to parameters.\\r\\n int i;\\r\\n int N = partial_array->dimensions[0];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n for (i=0;i<N;i++){\\r\\n %s\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(diag_grad_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n\\r\\n # Code for gradients wrt X, TODO: may need to deal with special case where one input is actually an output.\\r\\n gradX_func_list = []\\r\\n if self.output_dim>1:\\r\\n gradX_func_list += c_define_output_indices\\r\\n gradX_func_list += [\\\"TARGET2(i, %i) += PARTIAL2(i, j)*dk_dx_%i(%s);\\\"%(q,q,arg_string) for q in range(self._real_input_dim)]\\r\\n gradX_func_string = \\\"\\\\n\\\".join(gradX_func_list)\\r\\n\\r\\n self._dK_dX_code = \\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dK_dX_code\\r\\n // Code for computing gradient of covariance with respect to inputs.\\r\\n int i;\\r\\n int j;\\r\\n int N = partial_array->dimensions[0];\\r\\n int num_inducing = partial_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N; i++){\\r\\n for (j=0; j<num_inducing; j++){\\r\\n %s\\r\\n }\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(gradX_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n \\r\\n\\r\\n diag_gradX_func_string = re.sub('Z','X',gradX_func_string,count=0)\\r\\n diag_gradX_func_string = re.sub('int jj','//int jj',diag_gradX_func_string)\\r\\n diag_gradX_func_string = re.sub('j','i',diag_gradX_func_string)\\r\\n diag_gradX_func_string = re.sub('PARTIAL2\\\\(i, i\\\\)','2*PARTIAL1(i)',diag_gradX_func_string)\\r\\n\\r\\n # Code for gradients of Kdiag wrt X\\r\\n self._dKdiag_dX_code= \\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dKdiag_dX_code\\r\\n // Code for computing gradient of diagonal with respect to inputs.\\r\\n int N = partial_array->dimensions[0];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n for (int i=0;i<N; i++){\\r\\n %s\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(diag_gradX_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a\\r\\n # string representation forces recompile when needed Get rid\\r\\n # of Zs in argument for diagonal. TODO: Why wasn't\\r\\n # diag_func_string called here? Need to check that.\\r\\n #self._dKdiag_dX_code = self._dKdiag_dX_code.replace('Z[j', 'X[i')\\r\\n\\r\\n # Code to use when only X is provided. \\r\\n self._dK_dtheta_code_X = self._dK_dtheta_code.replace('Z[', 'X[')\\r\\n self._dK_dX_code_X = self._dK_dX_code.replace('Z[', 'X[').replace('+= PARTIAL2(', '+= 2*PARTIAL2(') \\r\\n self._dK_dtheta_code_X = self._dK_dtheta_code_X.replace('Z2(', 'X2(')\\r\\n self._dK_dX_code_X = self._dK_dX_code_X.replace('Z2(', 'X2(')\\r\\n\\r\\n\\r\\n #TODO: insert multiple functions here via string manipulation\\r\\n #TODO: similar functions for psi_stats\\r\",\n \"def numerize():\\n pass\",\n \"def numeric(*args):\",\n \"def generate_cpp():\\n cpp_file = AUTOGEN_WARNING\\n cpp_file += \\\"// Implements basic nuclear data functions.\\\\n\\\"\\n cpp_file += \\\"#ifndef PYNE_IS_AMALGAMATED\\\\n\\\"\\n cpp_file += '#include \\\"atomic_data.h\\\"\\\\n'\\n cpp_file += '#include \\\"nucname.h\\\"\\\\n'\\n cpp_file += \\\"#endif\\\\n\\\"\\n cpp_file += \\\" \\\\n\\\"\\n cpp_file += \\\"void pyne::_load_atomic_mass_map_memory() { \\\\n\\\"\\n cpp_file += \\\" // header version of atomic weight table data \\\\n\\\"\\n cpp_file += \\\" //see if the data table is already loaded\\\\n\\\"\\n cpp_file += \\\" if(!atomic_mass_map.empty()) {\\\\n\\\"\\n cpp_file += \\\" return;\\\\n\\\"\\n cpp_file += \\\" } else { \\\\n\\\"\\n cpp_file += \\\" _insert_atomic_mass_map();\\\\n\\\"\\n cpp_file += \\\" }\\\\n\\\"\\n cpp_file += \\\" //see if the data table is already loaded\\\\n\\\"\\n cpp_file += \\\" if(!natural_abund_map.empty()) {\\\\n\\\"\\n cpp_file += \\\" return;\\\\n\\\"\\n cpp_file += \\\" } else { \\\\n\\\"\\n cpp_file += \\\" _insert_abund_map();\\\\n\\\"\\n cpp_file += \\\" }\\\\n\\\"\\n cpp_file += \\\" // calculate the atomic_masses of the elements \\\\n\\\"\\n cpp_file += \\\" std::map<int,double> :: iterator it;\\\\n\\\"\\n cpp_file += \\\" \\\\n\\\"\\n cpp_file += \\\" for (int z = 1; z <= 92 ; z++) {\\\\n\\\"\\n cpp_file += \\\" // loop through the natural abundance map\\\\n\\\"\\n cpp_file += \\\" double element_atomic_weight = 0.0;\\\\n\\\"\\n cpp_file += \\\" for (it = natural_abund_map.begin(); it != natural_abund_map.end() ; ++it){\\\\n\\\"\\n cpp_file += \\\" // if the atomic number of the abudance matches the\\\\n\\\"\\n cpp_file += \\\" // that of index\\\\n\\\"\\n cpp_file += \\\" if(pyne::nucname::znum(it->first) == z) {\\\\n\\\"\\n cpp_file += \\\" // take atomic abundance and multiply by mass\\\\n\\\"\\n cpp_file += (\\n \\\" // to get the mass of that nuclide / 100 since abundance is in %\\\\n\\\"\\n )\\n cpp_file += \\\" element_atomic_weight += (it->second*atomic_mass_map[it->first]/100.0);\\\\n\\\"\\n cpp_file += \\\" }\\\\n\\\"\\n cpp_file += \\\" }\\\\n\\\"\\n cpp_file += \\\" // insert the abundance of the element into the list\\\\n\\\"\\n cpp_file += \\\" atomic_mass_map[z*10000000] = element_atomic_weight;\\\\n\\\"\\n cpp_file += \\\" }\\\\n\\\"\\n cpp_file += \\\"}\\\\n\\\"\\n cpp_file += \\\"\\\\n\\\\n\\\"\\n cpp_file += \\\"void pyne::_insert_atomic_mass_map() { \\\\n\\\"\\n cpp_file += generate_atomic_mass()\\n cpp_file += \\\"}\\\\n\\\"\\n cpp_file += \\\"\\\\n\\\\n\\\"\\n cpp_file += \\\"void pyne::_insert_abund_map() { \\\\n\\\"\\n cpp_file += generate_abundances()\\n cpp_file += \\\"}\\\\n\\\"\\n return cpp_file\",\n \"def generate():\",\n \"def genCode(self):\\n # Init variables and environment.\\n if 'Sys' in self.inputs:\\n self.cg_bootstrap_sys()\\n\\n for ns, vm_code in self.inputs.items():\\n input = Parser(vm_code).parse()\\n self.ns = ns\\n\\n if input['errors']:\\n # No meaningful output can be generated.\\n # Print errors to stderr and return empty string.\\n print(\\\"ERRORS\\\", file=sys.stderr)\\n for err in input['errors']:\\n print(\\\"Line {}: {}\\\".format(err.line, err.msg))\\n return f\\\"// Encountered errors parsing {filename}\\\"\\n\\n # Translate input.\\n self.asm(f\\\"// Input file: {ns}\\\")\\n for cmd in input['commands']:\\n # Print original VM command as a comment.\\n self.asm('// ' + cmd.src)\\n self.cg(cmd)\\n self.asm(f\\\"// End of input file: {ns}\\\")\\n\\n # Add the stop loop.\\n self.cg_stop()\\n\\n return '\\\\n'.join(self.text)\",\n \"def curve_number(self):\",\n \"def v_numeric(self, **kwargs):\\n self.system.groups['StaticGen'].set(src='u', idx=self.gen.v, attr='v', value=0)\",\n \"def getNumber():\",\n \"def gen_code():\\n return ''.join([random.choice(string.ascii_uppercase + string.digits) for _ in range(10)])\",\n \"def generate(self):\\n tempSn_1 = self.sn_1\\n self.sn_1 = (self.an_2*self.sn_2 + self.an_1*self.sn_1) % self.mod\\n self.sn_2 = tempSn_1\\n return self.sn_1 / self.mod\",\n \"def main():\\n result = 0\\n for n in range(1, 1001):\\n result += n**n\\n\\n result = str(result)\\n answer = result[len(result)-10::]\\n\\n print \\\"answer: \\\" + answer\",\n \"def generate_swift_code(self, num):\\n swift_code = []\\n for _ in range(num):\\n swift_code.append(self.fake.swift())\\n return swift_code\",\n \"def gencode(self):\\n\\n fullcode = self.code_cfg\\n variables = codeconfig_getvars(fullcode)\\n if len(variables) > 0:\\n variables.sort(key=lambda x: len(x), reverse=True)\\n for va in variables:\\n if eval(\\\"self.\\\" + va[1:]) is None or eval(\\\"self.\\\" + va[1:]) == \\\"\\\":\\n warnings.warn(\\\"Inserting None for \\\" + va, UserWarning)\\n fullcode = fullcode.replace(va, str(eval(\\\"self.\\\" + va[1:])))\\n # testing for sintax errors\\n #compile(fullcode, \\\"<Test ModelCall Code>\\\\n\\\" + fullcode, 'exec')\\n tmpfile = os.path.join(gettempdir(), \\\"TestModelCallCode.\\\" + self.complexity + \\\".py\\\")\\n with open(tmpfile, \\\"w\\\") as f: f.write(fullcode)\\n compile(fullcode, tmpfile, 'exec')\\n return fullcode\",\n \"def code():\",\n \"def test_numbers(self):\\n \\n result = gen_expansion(sym.pi, 2)\\n self.assertEqual(result, '14')\\n result = gen_expansion(sym.exp(1), 2)\\n self.assertEqual(result, '72')\",\n \"def evaluate(self) -> int:\",\n \"def _pettifor_numbers():\\n return { \\\"Li\\\": 0.45,\\n \\\"Be\\\": 1.5,\\n \\\"B\\\": 2.0,\\n \\\"C\\\": 2.5,\\n \\\"N\\\": 3.0, \\n \\\"O\\\": 3.5,\\n \\\"F\\\": 4.0,\\n \\n \\\"Na\\\": 0.4,\\n \\\"Mg\\\": 1.28,\\n \\\"Al\\\": 1.66,\\n \\\"Si\\\": 1.92,\\n \\\"P\\\": 2.18,\\n \\\"S\\\": 2.44,\\n \\\"Cl\\\": 2.70,\\n \\n \\\"K\\\": 0.35,\\n \\\"Ca\\\": 0.60,\\n \\\"Sc\\\": 0.74,\\n \\\"Ti\\\": 0.79,\\n \\\"V\\\": 0.84,\\n \\\"Cr\\\": 0.89,\\n \\\"Mn\\\": 0.94,\\n \\\"Fe\\\": 0.99,\\n \\\"Co\\\": 1.04,\\n \\\"Ni\\\": 1.09,\\n \\\"Cu\\\": 1.20,\\n \\\"Zn\\\": 1.44,\\n \\\"Ga\\\": 1.68,\\n \\\"Ge\\\": 1.92,\\n \\\"As\\\": 2.16,\\n \\\"Se\\\": 2.40,\\n \\\"Br\\\": 2.64,\\n\\n \\\"Rb\\\": 0.30,\\n \\\"Sr\\\": 0.55,\\n \\\"Y\\\": 0.70,\\n \\\"Zr\\\": 0.76,\\n \\\"Nb\\\": 0.82,\\n \\\"Mo\\\": 0.88,\\n \\\"Tc\\\": 0.94,\\n \\\"Ru\\\": 1.00,\\n \\\"Rh\\\": 1.06,\\n \\\"Pd\\\": 1.12,\\n \\\"Ag\\\": 1.18,\\n \\\"Cd\\\": 1.36,\\n \\\"In\\\": 1.60,\\n \\\"Sn\\\": 1.84,\\n \\\"Sb\\\": 2.08,\\n \\\"Te\\\": 2.32,\\n \\\"I\\\": 2.56,\\n \\n \\\"Cs\\\": 0.25,\\n \\\"Ba\\\": 0.50,\\n \\\"La\\\": 0.748,\\n \\\"Hf\\\": 0.775,\\n \\\"Ta\\\": 0.83,\\n \\\"W\\\": 0.885,\\n \\\"Re\\\": 0.94,\\n \\\"Os\\\": 0.995,\\n \\\"Ir\\\": 1.05,\\n \\\"Pt\\\": 1.105,\\n \\\"Au\\\": 1.16,\\n \\\"Hg\\\": 1.32,\\n \\\"Tl\\\": 1.56,\\n \\\"Pb\\\": 1.80,\\n \\\"Bi\\\": 2.04,\\n \\\"Po\\\": 2.28, \\n \\\"At\\\": 2.52 }\",\n \"def Mo96(self,dc,nu):\\n return 1. + (nu**2.-1.)/dc\",\n \"def _generate_code_blocks(self):\\n\\n printer = self._generate_pydy_c_printer()()\\n\\n self.code_blocks = {}\\n\\n lines = []\\n for i, input_arg in enumerate(self.arguments):\\n lines.append('double input_{}[{}],'.format(i, len(input_arg)))\\n self.code_blocks['input_args'] = wrap_and_indent(lines, 14)\\n\\n lines = []\\n for i, output_arg in enumerate(self.matrices):\\n nr, nc = output_arg.shape\\n lines.append('double output_{}[{}],'.format(i, nr * nc))\\n self.code_blocks['output_args'] = \\\\\\n wrap_and_indent(lines, 14)[:-1] # remove last comma\\n\\n lines = []\\n for i, (input_arg, explan) in enumerate(zip(self.arguments,\\n self.comma_lists())):\\n lines.append('input_{}[{}] : [{}]'.format(i, len(input_arg),\\n explan))\\n self.code_blocks['input_docstring'] = wrap_and_indent(lines, 0)\\n\\n lines = []\\n for var, expr in self.subexprs:\\n var_str = printer.doprint(var)\\n expr_str = printer.doprint(expr)\\n lines.append('double {} = {};'.format(var_str, expr_str))\\n self.code_blocks['subexprs'] = wrap_and_indent(lines)\\n\\n outputs = ''\\n for i, output in enumerate(self.simplified_matrices):\\n nr, nc = output.shape\\n lhs = sm.MatrixSymbol('output_{}'.format(i), nr, nc)\\n try:\\n code_str = printer.doprint(output, lhs)\\n except AttributeError:\\n # The above fails in SymPy 0.7.4.1 because Matrix printing\\n # isn't supported.\\n code_lines = []\\n for j, element in enumerate(output):\\n assignment = 'output_{}[{}]'.format(i, j)\\n code_lines.append(printer.doprint(element, assignment))\\n code_str = '\\\\n'.join(code_lines)\\n outputs += wrap_and_indent(code_str.split('\\\\n'))\\n if i != len(self.simplified_matrices) - 1:\\n outputs += '\\\\n\\\\n' # space between each output\\n\\n self.code_blocks['outputs'] = outputs\",\n \"def main():\\n for i in range(11):\\n i = i / 10\\n print('L * 1000', i, L(i) * 1000)\",\n \"def data_generation():\\n num1 = random.randint(1, 100)\\n num2 = random.randint(1, 100)\\n correct_answer = math.gcd(num1, num2)\\n expression = f'{num1} {num2}'\\n return expression, str(correct_answer)\",\n \"def code_str(self, fn_name):\\n code = CodeWriter()\\n code.wl(\\\"def \\\" + fn_name + \\\"(y):\\\")\\n code.inc_indent()\\n if self.m == 1:\\n code.wl(\\\"x = \\\" + str(self._a) + \\\" * y + \\\" + str(self._b))\\n else:\\n code.wl(\\\"a = np.\\\" + self._a.__repr__())\\n code.wl(\\\"b = np.\\\" + self._b.__repr__())\\n code.wl(\\\"x = np.dot(a, y) + b\\\")\\n poly_eval_code = self._unit_simplex_polynomial.code_str(\\\"temp\\\")\\n poly_eval_code = poly_eval_code.split('\\\\n')[1:]\\n poly_eval_code = \\\"\\\\n\\\".join(poly_eval_code)\\n code.verbatim(poly_eval_code)\\n code.dec_indent()\\n return code.code\",\n \"def generate(bits):\\r\\n raise NotImplementedError()\",\n \"def _generate_code(x, functional):\\n\\n printer = sympy.printing.lambdarepr.PythonCodePrinter()\\n\\n code = \\\"def evaluate(values, solution):\\\\n\\\"\\n code += \\\"\\\\tfor k in range(len(values)):\\\\n\\\"\\n code += \\\"\\\\t\\\\t\\\" + \\\", \\\".join(str(state) for state in x) + \\\" = solution[k]\\\\n\\\"\\n code += f\\\"\\\\t\\\\tvalues[k] = {printer.doprint(functional.evalf())}\\\\n\\\"\\n return code\",\n \"def generate(self):\",\n \"def code() -> str:\\n return \\\"\\\"\\\"\\n G91 G17\\n G0 Y10 X-10\\n G0 Y0 X-5\\n G0 Y5 X0\\n G0 Y0 X5\\n G0 Y0 X-5\\n G0 Y-5 X0\\n G3 Y-5 X5 J0 I5\\n G0 Y0 X5\\n G0 Y5 X0\\n G3 Y5 X-5 J0 I-5\\n G0 Y-5 X0\\n G0 Y-10 X10\\n G0 Y0 X-5\\n G0 Y-15 X-15\\n G0 Y0 X5\\n G0 Y5 X0\\n G0 Y0 X-5\\n G0 Y-5 X0\\n G0 Y5 X0\\n G2 Y5 X5 J0 I5\\n G0 Y0 X5\\n G0 Y-5 X0\\n G2 Y-5 X-5 J0 I-5\\n G0 Y5 X0\\n G0 Y10 X10\\n G0 Y0 X-30\\n G3 Y0 X-10 J0 I-5\\n G3 Y0 X10 J0 I5\\n\\n G0 Y0 X5\\n G3 Y5 X5 J5 I0\\n G3 Y10 X-10 J0 I-10\\n G3 Y-5 X-5 J-5 I0\\n G0 Y-5 X0\\n\\n G0 Y5 X0\\n G3 Y5 X-5 J0 I-5\\n G3 Y-10 X-10 J-10 I0\\n G3 Y-5 X5 J0 I5\\n G0 Y0 X5\\n\\n G0 Y0 X-5\\n G3 Y-5 X-5 J-5 I0\\n G3 Y-10 X10 J0 I10\\n G3 Y5 X5 J5 I0\\n G0 Y5 X0\\n\\n G0 Y-5 X0\\n G3 Y-5 X5 J0 I5\\n G3 Y10 X10 J10 I0\\n G3 Y5 X-5 J0 I-5\\n G0 Y0 X-5\\n \\\"\\\"\\\"\",\n \"def calculate(self):\\n\\n outs = map(str, map(self.translate, self.nums))\\n result = \\\"\\\\n\\\".join(outs)\\n\\n return str(result)\",\n \"def test_generate_nb(self):\\n pass\",\n \"def __math__(inputs: list) -> str:\\n # TODO: Find new way of indicating that a variable should be used instead of a static value.\\n\\n out = \\\"\\\"\\n if len(inputs) < 2:\\n return None # TODO: create error and throw that instead\\n fname, func = inspect.getmembers(math, inspect.isbuiltin)[inputs[0]]\\n out += fname + \\\"(\\\"\\n nvars = MachineInterface.__math_doc_nvars__(func.__doc__)\\n if nvars == 1:\\n out += str(inputs[1]) + \\\",\\\"\\n else:\\n for i in range(1, nvars):\\n out += str(inputs[i % len(inputs)]) + \\\",\\\"\\n\\n return out[:-1] + \\\")\\\"\\n # b = func.__doc__\\n # print(dir(func))\\n # print(b)\\n # print(dir(b))\\n # print(inspect.signature(b)\",\n \"def code_format(self):\\n return \\\"^\\\\\\\\d{%s}$\\\" % self._digits\",\n \"def make_g_number():\\n return fake.bothify(text='??#########')\",\n \"def y(self) -> int:\",\n \"def GenerateCode(self):\\n print \\\"Generating code...\\\"\\n for type in self.getObjectTypes():\\n generator = __import__(\\\"codegen.Cpp\\\" + type, globals(), locals(), [''])\\n print \\\"Generating code for objects of type: %s\\\" % type\\n generator.GenerateCode(self)\",\n \"def function(self):\\n return self.generator.module.neumannx\",\n \"def random_num(self):\\r\\n self.generate_n1()\\r\\n self.generate_n2()\\r\\n self.generate_n3()\\r\\n self.generate_n4()\\r\\n random_number = str(self.n_1decimal)+str(self.n_2decimal)+str(self.n_3decimal)+str(self.n_4decimal)\\r\\n print int(random_number)\",\n \"def generate_new_code():\\n code = ''.join(random.choice(string.digits) for i in range(6))\\n return code\",\n \"def GenerateNormalExpression(n):\\n if int(n) != n or n < 1:\\n return None\\n return '+'.join(['a[%d]' % ii for ii in range(n)])\",\n \"def make_code(self, datasetname):\\n try:\\n if(datasetname):\\n for i in range(1, len(self.extract()) + 1):\\n self.formated = datasetname + \\\"%03d\\\" % (i,)\\n yield self.formated \\n except:\\n raise\",\n \"def NACA4digitsSym(self):\\n self.ytu = self.NacaEquation(self.xu,self.t)\\n self.ytl = -self.NacaEquation(self.xl,self.t)\\n # Done for estitic reasons\\n self.yu = self.ytu \\n self.yl = self.ytl\\n self.z = np.concatenate((self.yu, np.flip(self.yl)))\\n if self.plot:\\n plt.figure(self.name)\\n plt.title(self.name)\\n plt.plot(self.xu,self.yu)\\n plt.plot(self.xl,self.yl)\\n plt.axis('equal')\",\n \"def generate(self):\\r\\n raise NotImplementedError\",\n \"def generate_code(model, dataloader, code_length, device):\\n model.eval()\\n with torch.no_grad():\\n N = len(dataloader.dataset)\\n code = torch.zeros([N, code_length])\\n for data, _, index in dataloader:\\n data = data.to(device)\\n hash_code = model(data)\\n code[index, :] = hash_code.sign().cpu()\\n\\n model.train()\\n return code\",\n \"def gen_amounts(no_cultures):\\n # Init amounts\\n C = 0.01\\n N = 1.0\\n S = 0.0\\n init_amounts = np.array([C, N, S]*no_cultures)\\n return init_amounts\",\n \"def calculate_output(self):\",\n \"def Codingfunc(N,L): #Coding:[N:number of repetitions, L:length of single/multiple sequence]\\r\\n C=0 #int variable containing code number\\r\\n if N==1:\\r\\n C=L-1\\r\\n else:\\r\\n C=-(L-1)*16-(N-1)\\r\\n #print(\\\"C =\\\",C,end=' ')\\r\\n \\r\\n return struct.pack('b',C)\",\n \"def calculate(self):\",\n \"def generate_code(spn_id, spn, meta_types, floating_data_type):\\r\\n\\r\\n # make sure we have ids\\r\\n assign_ids(spn)\\r\\n\\r\\n # fill method body according to SPN structure\\r\\n method_body = generate_method_body(spn, spn, floating_data_type, 0)\\r\\n\\r\\n # build parameters used in generated c++ function\\r\\n method_params = []\\r\\n passed_params = []\\r\\n for i, type in enumerate(meta_types):\\r\\n if type == MetaType.DISCRETE:\\r\\n method_params += [f'vector <int> possibleValues{i}', f'int nullValueIdx{i}']\\r\\n passed_params += [f'py::arg(\\\"possibleValues{i}\\\")', f'py::arg(\\\"nullValueIdx{i}\\\")']\\r\\n elif type == MetaType.REAL:\\r\\n method_params += [f'bool inverse{i}', f'bool leftMinusInf{i}', f'float leftCondition{i}',\\r\\n f'bool rightMinusInf{i}', f'float rightCondition{i}', f'bool leftIncluded{i}',\\r\\n f'bool rightIncluded{i}', f'float nullValue{i}']\\r\\n passed_params += [f'py::arg(\\\"inverse{i}\\\")', f'py::arg(\\\"leftMinusInf{i}\\\")', f'py::arg(\\\"leftCondition{i}\\\")',\\r\\n f'py::arg(\\\"rightMinusInf{i}\\\")', f'py::arg(\\\"rightCondition{i}\\\")',\\r\\n f'py::arg(\\\"leftIncluded{i}\\\")', f'py::arg(\\\"rightIncluded{i}\\\")', f'py::arg(\\\"nullValue{i}\\\")']\\r\\n\\r\\n value_dictionary = {\\r\\n 'spn_id': spn_id,\\r\\n 'method_body': method_body,\\r\\n 'method_params': ', '.join(method_params),\\r\\n 'node_count': get_number_of_nodes(spn),\\r\\n 'passed_params': ', '.join(passed_params),\\r\\n 'floating_data_type': floating_data_type\\r\\n }\\r\\n generated_method = replace_template(TemplatePath.METHOD_MASTER, value_dictionary, 0)\\r\\n registrate_method = replace_template(TemplatePath.REGISTRATION_MASTER, value_dictionary, 0)\\r\\n\\r\\n return generated_method, registrate_method\",\n \"def problem_48():\\n\\n return int(str(sum(x**x for x in range(1, 1001)))[-10:])\",\n \"def function(self):\\n return self.generator.module.neumannz\",\n \"def valor(self):\\n nbits = len(self.gens)\\n dec = int(self.gens,2)\\n real = self.min+dec*((self.max-self.min)/(math.pow(2,nbits)-1))\\n return real\",\n \"def gen_code(self, compile_unit):\\n self.builder = irutils.Builder()\\n self.ir_var_map = {}\\n self.logger.debug(\\\"Generating IR-code\\\")\\n self.debug_db = debuginfo.DebugDb()\\n ir_mod = ir.Module(\\\"main\\\", debug_db=self.debug_db)\\n self.builder.module = ir_mod\\n\\n # Split declaration into functions and variables:\\n functions = []\\n variables = []\\n for declaration in compile_unit.declarations:\\n assert isinstance(declaration, declarations.CDeclaration)\\n\\n if isinstance(\\n declaration,\\n (declarations.Typedef, declarations.EnumConstantDeclaration),\\n ):\\n pass\\n elif isinstance(declaration, declarations.FunctionDeclaration):\\n functions.append(declaration)\\n elif isinstance(declaration, declarations.VariableDeclaration):\\n variables.append(declaration)\\n else: # pragma: no cover\\n raise NotImplementedError(str(declaration))\\n\\n # Generate code:\\n for variable in variables:\\n self.gen_global_variable(variable)\\n\\n for function in functions:\\n self.create_function(function)\\n\\n for function in functions:\\n self.gen_function(function)\\n\\n self.logger.info(\\\"Finished IR-code generation\\\")\\n return ir_mod\",\n \"def NumericString_ (typecode, value) :\\r\\n if typecode == 'f' :\\r\\n return formatHelp_(\\\"%#.7G\\\", value)\\r\\n \\r\\n elif typecode == 'd' :\\r\\n return formatHelp_(\\\"%#.16G\\\", value)\\r\\n \\r\\n elif typecode == 'F' :\\r\\n front = '('+formatHelp_(\\\"%#.7G\\\", value.real, strip_all_zeros=True)\\r\\n if value.imag==0 :\\r\\n front += \\\"+0j)\\\"\\r\\n else :\\r\\n front += formatHelp_(\\\"%+#.7G\\\", value.imag, strip_all_zeros=True)+\\\"j)\\\"\\r\\n return front\\r\\n \\r\\n elif typecode == 'D' :\\r\\n front = '('+formatHelp_(\\\"%#.16G\\\", value.real, strip_all_zeros=True)\\r\\n if value.imag==0 :\\r\\n front += \\\"+0j)\\\"\\r\\n else :\\r\\n front += formatHelp_(\\\"%+#.16G\\\", value.imag, strip_all_zeros=True)+\\\"j)\\\"\\r\\n return front\\r\\n \\r\\n else :\\r\\n return str(value)\",\n \"def calculate_exponent():\\n pass\",\n \"def numer(self, a):\\n raise NotImplementedError\",\n \"def genRate(self):\\n\\n # We need to compute normEsquared before we can compute the generation\\n # rate\\n normEsq = self.get_scalar_quantity('normEsquared')\\n # Prefactor for generation rate. Note we gotta convert from m^3 to\\n # cm^3, hence 1e6 factor\\n fact = consts.epsilon_0 / (consts.hbar * 1e6)\\n gvec = np.zeros_like(normEsq)\\n # Main loop to compute generation in each layer\\n freq = self.conf[('Simulation', 'params', 'frequency')]\\n for name, layer in self.layers.items():\\n self.log.debug('LAYER: %s', name)\\n self.log.debug('LAYER T: %f', layer.thickness)\\n self.log.debug('START: %f', layer.start)\\n self.log.debug('END: %f', layer.end)\\n # Use the layer object to get the nk matrix with correct material\\n # geometry\\n nmat, kmat = layer.get_nk_matrix(freq, self.X, self.Y)\\n gvec[layer.get_slice(self.Z)] = fact * nmat * kmat * normEsq[layer.get_slice(self.Z)]\\n # gvec[layer.get_slice()] = nmat * kmat * normEsq[layer.get_slice(self.Z)]\\n self.extend_data('genRate', gvec)\\n return gvec\",\n \"def _rawprng(self):\\n self.p += 1 \\n if self.p >= self.o:\\n\\t\\t\\tself.p = 0\\n t = 1768863 * self.s[self.p] + self.c * 2.3283064365386963e-10\\n self.c = int(t) | 0\\n self.s[self.p] = t - self.c\\n return self.s[self.p]\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def ccode(self):\\n from devito.ir.iet.visitors import CGen\\n return CGen().visit(self)\",\n \"def get_fitness_function_c_code(self):\\n s = \\\"\\\"\\\"FLOAT fitness_function(FLOAT phi, FLOAT chi, FLOAT omega)\\n {\\n FLOAT fitness = absolute(phi);\\n return fitness;\\n }\\n \\\"\\\"\\\" \\n return s\",\n \"def get_fitness_function_c_code(self):\\n s = \\\"\\\"\\\"FLOAT fitness_function(FLOAT phi, FLOAT chi, FLOAT omega)\\n {\\n FLOAT fitness = absolute(phi);\\n return fitness;\\n }\\n \\\"\\\"\\\" \\n return s\",\n \"def create_code():\\n\\n code = [0, 0, 0, 0]\\n\\n for i in range(4):\\n value = random.randint(1, 8) # 8 possible digits\\n while value in code:\\n value = random.randint(1, 8) # 8 possible digits\\n code[i] = value\\n \\n #print(code)\\n return code\",\n \"def function(self):\\n return self.generator.module.neumann\",\n \"def genus(self):\\n return 1 - self.euler_characteristic() // 2\",\n \"def value(self):\\n try: return 10.**(self._value)\\n except AttributeError: raise GAError, 'gene not initialized'\",\n \"def gm2code(arr, info):\\n return (arr / info.pboxsize + 0.5)# * 0.999783599\",\n \"def generate_code_implementation(name, code, comment=None):\\n k = code.dimension()\\n cs, _p = code.standard_form()\\n info = {\\n 'name': name,\\n 'n': code.length(),\\n 'k': k,\\n 'generator': [bools_to_binvec(row) for row in cs.systematic_generator_matrix()],\\n 'generator_bools': cs.systematic_generator_matrix(),\\n 'parity_matrix': [bools_to_binvec(row) for row in cs.parity_check_matrix()],\\n \\\"comment\\\": comment,\\n }\\n\\n max_error = code.decoder().maximum_error_weight()\\n\\n syndrome_map = {}\\n for (he, error) in cs.decoder().syndrome_table().items():\\n syndrome_map[ZZ(list(he), base=2)] = bools_to_binvec(error)\\n\\n info['syndrome_map'] = syndrome_map\\n info['syndrome_map_itemlen'] = len(list(syndrome_map.values())[0])\\n\\n assert max(syndrome_map) < 2**64, \\\"sydrome map too big!\\\"\\n \\n info['info_set'] = cs.information_set()\\n\\n testcases = []\\n if 'might-error' in cs.decoder().decoder_type():\\n max_error -= 3\\n for _ in range(20):\\n randvec = random_vector(GF(2), code.length())\\n codeword = cs.decode_to_code(randvec)\\n testcase = {\\n 'randvec': randvec,\\n 'codeword': codeword,\\n }\\n testcases.append(testcase)\\n\\n info['testcases'] = testcases\\n\\n with open('syndrome_code_implementation.rs.j2', 'r') as templatefile:\\n template = ENVIRONMENT.from_string(templatefile.read())\\n with open('{name}/{name}_{n}_{k}.rs'.format(name=name.lower(),\\n n=code.length(), k=k),\\n 'w') as outputfile:\\n outputfile.write(template.render(**info))\\n\\n rendered_codes[name].append((code.length(), code.dimension()))\",\n \"def generate(self):\\n return self.gen.generate()\",\n \"def typecode (self) :\\r\\n return self.numeric_typecode\",\n \"def power_gen(k):\\n if k == 0:\\n return constant\\n if k == 1:\\n return identity\\n @natural_input\\n def power_k(n):\\n return n ** k\\n return power_k\",\n \"def _numeric_jacobian(self):\\n if self.__numeric_jacobian is None:\\n self.__numeric_jacobian = self._lambdify(self._symbolic_jacobian)\\n return self.__numeric_jacobian\",\n \"def make_anonymous_factorial():\\n return 'YOUR_EXPRESSION_HERE'\",\n \"def make_anonymous_factorial():\\n return 'YOUR_EXPRESSION_HERE'\",\n \"def make_anonymous_factorial():\\n return 'YOUR_EXPRESSION_HERE'\",\n \"def make_anonymous_factorial():\\n return 'YOUR_EXPRESSION_HERE'\",\n \"def numer(self, a):\\n return a\",\n \"def generateCodeWithoutIndices(self, codeGenerator):\\n return self.variable.generateCode(codeGenerator)\",\n \"def generate(self):\\n pass\",\n \"def n():\\n # For documentation purposes\",\n \"def generate(self):\\n start = self.nu_idx\\n stop = start + self.score\\n return self.orig_nu[start:stop]\",\n \"def fortran_functions(self) -> str:\\n fun_name = f'{self.f_prefix}_{self.name}_to_int_'\\n result = f'integer function {fun_name}(flags)\\\\n'\\n result += ' implicit none\\\\n'\\n result += '\\\\n'\\n result += f' class({self.f_prefix}_{self.name}), intent(in) :: flags\\\\n'\\n result += ' integer :: ret_val\\\\n'\\n result += '\\\\n'\\n result += ' ret_val = 0\\\\n'\\n for i, value in enumerate(self.values):\\n result += f\\\" if (flags%{value}) ret_val = ret_val + {1 << i}\\\\n\\\"\\n result += f' {fun_name} = ret_val\\\\n'\\n result += f'end function {fun_name}\\\\n'\\n return indent(result, 4*' ')\",\n \"def generate(self):\\n pass\",\n \"def generate(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66350216","0.6155325","0.6070667","0.60567296","0.6001382","0.5999806","0.5950534","0.5930682","0.58927596","0.5881666","0.5805855","0.57972014","0.5767194","0.5750545","0.5731919","0.5724899","0.57187545","0.56876415","0.5651061","0.564188","0.5631152","0.5618048","0.5610541","0.5593706","0.55687916","0.5566384","0.5553317","0.5544792","0.5536363","0.5524753","0.5491659","0.5484553","0.547359","0.54648966","0.54603946","0.5424518","0.54062986","0.539802","0.53633404","0.5356967","0.53446174","0.5333481","0.53321135","0.53303194","0.53244406","0.5320012","0.53111434","0.5310648","0.53087324","0.5304848","0.5293291","0.52908844","0.52899855","0.52870584","0.52800214","0.5279358","0.52662784","0.5258946","0.525734","0.52444535","0.52377933","0.52352643","0.5235128","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52134407","0.52112687","0.52112687","0.51981974","0.5197065","0.5188733","0.51804525","0.51785547","0.5168554","0.51629084","0.51569605","0.51539624","0.5153407","0.51477504","0.51477504","0.51477504","0.51477504","0.51461905","0.5143231","0.514067","0.51395833","0.5138481","0.51342964","0.51289666","0.51289666"],"string":"[\n \"0.66350216\",\n \"0.6155325\",\n \"0.6070667\",\n \"0.60567296\",\n \"0.6001382\",\n \"0.5999806\",\n \"0.5950534\",\n \"0.5930682\",\n \"0.58927596\",\n \"0.5881666\",\n \"0.5805855\",\n \"0.57972014\",\n \"0.5767194\",\n \"0.5750545\",\n \"0.5731919\",\n \"0.5724899\",\n \"0.57187545\",\n \"0.56876415\",\n \"0.5651061\",\n \"0.564188\",\n \"0.5631152\",\n \"0.5618048\",\n \"0.5610541\",\n \"0.5593706\",\n \"0.55687916\",\n \"0.5566384\",\n \"0.5553317\",\n \"0.5544792\",\n \"0.5536363\",\n \"0.5524753\",\n \"0.5491659\",\n \"0.5484553\",\n \"0.547359\",\n \"0.54648966\",\n \"0.54603946\",\n \"0.5424518\",\n \"0.54062986\",\n \"0.539802\",\n \"0.53633404\",\n \"0.5356967\",\n \"0.53446174\",\n \"0.5333481\",\n \"0.53321135\",\n \"0.53303194\",\n \"0.53244406\",\n \"0.5320012\",\n \"0.53111434\",\n \"0.5310648\",\n \"0.53087324\",\n \"0.5304848\",\n \"0.5293291\",\n \"0.52908844\",\n \"0.52899855\",\n \"0.52870584\",\n \"0.52800214\",\n \"0.5279358\",\n \"0.52662784\",\n \"0.5258946\",\n \"0.525734\",\n \"0.52444535\",\n \"0.52377933\",\n \"0.52352643\",\n \"0.5235128\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52134407\",\n \"0.52112687\",\n \"0.52112687\",\n \"0.51981974\",\n \"0.5197065\",\n \"0.5188733\",\n \"0.51804525\",\n \"0.51785547\",\n \"0.5168554\",\n \"0.51629084\",\n \"0.51569605\",\n \"0.51539624\",\n \"0.5153407\",\n \"0.51477504\",\n \"0.51477504\",\n \"0.51477504\",\n \"0.51477504\",\n \"0.51461905\",\n \"0.5143231\",\n \"0.514067\",\n \"0.51395833\",\n \"0.5138481\",\n \"0.51342964\",\n \"0.51289666\",\n \"0.51289666\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":87195,"cells":{"query":{"kind":"string","value":"Return the generated function"},"document":{"kind":"string","value":"def function(self):\n return self.generator.module.bounce_back"},"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 getFunction(self) -> ghidra.program.model.listing.Function:\n ...","def gen_function(self, function):\n if function.body:\n self.gen_function_def(function)","def func ( self ) :\n return self.__func","def func ( self ) :\n return self.__func","def __call__(self):\n return self.generate()","def RandomFunction(self):\r\n return self._random_fn","def __call__(fun_name):","def _func(self):\n return self._get_flint_func(self.domain)","def function(self):\n raise NotImplementedError","def _gen_closure(fnc,arg):\n return lambda s: fnc(arg)","def get_function(self):\n return subs(self.f.get_function(), self.sub_pre, self.sub_post)","def fn():","def get_gen_loop_fun(param_dict, fun_dict):\n def f(x_pl, hid_pl, count, f_state, eps_z, eps_x):\n return gen_loop(x_pl, hid_pl, count, f_state, eps_z, eps_x, param_dict, fun_dict)\n return f","def generate():","def make_transform_fn(self, ):\n return self._transform_fn","def createTransformFunc(self):\n raise NotImplementedError()","def get_transform_fn():","def generate(self, namespace: Optional[str], template: str, func: Callable, call_args: Dict) -> str:","def function(self):\n return self.generator.module.neumannz","def func():","def function(self):\n return self.generator.module.neumannx","def get_function(self):\n raise NotImplementedError()","def function(self):\n return self.generator.module.neumanny","def getFunction(self, name: unicode) -> ghidra.program.model.listing.Function:\n ...","def _create_function(self, expr):\n bb_entry = self.fn.append_basic_block('entry')\n builder = ll.IRBuilder(bb_entry)\n\n lj = LLVMJitCallbackPrinter(self.module, builder, self.fn,\n func_arg_map=self.param_dict)\n\n ret = self._convert_expr(lj, expr)\n\n if self.signature.ret_arg:\n output_fp_ptr = builder.bitcast(self.fn.args[self.signature.ret_arg],\n ll.PointerType(self.fp_type))\n for i, val in enumerate(ret):\n index = ll.Constant(ll.IntType(32), i)\n output_array_ptr = builder.gep(output_fp_ptr, [index])\n builder.store(val, output_array_ptr)\n builder.ret(ll.Constant(ll.IntType(32), 0)) # return success\n else:\n lj.builder.ret(self._wrap_return(lj, ret))\n\n strmod = str(self.module)\n return strmod","def _generate_fun(self, name, specstr, resname, specnames, docodeinserts=False):\n\n fdef = self._fn_template.format(\n name=name,\n start=self._format_user_code(self.opts['start']) if docodeinserts else '',\n spec=specstr,\n end=self._format_user_code(self.opts['end']) if docodeinserts else '',\n result=makeParList(range(len(specnames)), resname)\n )\n return '\\n'.join([s for s in fdef.split('\\n') if s]) + '\\n'","def generate(self):","def __call__(self):\n return self.fn()","def getFunction(self):\n return lambda x: self.slope * x + self.ordinate","def get_decorated_function(self):","def convert_function(self, access_modifier, return_type, func_name, params):\n\n # Run super func_name\n access_modifier, return_type, func_name, params = \\\n super().convert_function(access_modifier, return_type,\n func_name, params)\n\n # Make and return processed function definition\n return [self.make_function_definition(return_type, func_name, params)], []","def make_function(self):\n result = {}\n x0 = 0\n for i, x in enumerate(self.step_vals):\n vals_range = xrange(x0, x)\n for k in vals_range:\n result[k] = i\n x0 = x\n self.function = result","def function(self):\n return self.generator.module.neumann","def fn(self):\n return self._fn","def getCallable():","def view_function(self,v):\n return v","def function(self, name):\n return function_documentor(name)","def generate(self):\r\n raise NotImplementedError","def GenerateSpecialFunction(n):\n return eval('lambda a: %s' % GenerateSpecialExpression(n))","def createFunction(self, entryPoint: ghidra.program.model.address.Address, name: unicode) -> ghidra.program.model.listing.Function:\n ...","def f():","def f():","def get_now_func():\n return _now_func[0]","def cpp_function(self):","def _generate_and_save_function(self, filename, expression, parameters):\n\n # check for / create the save folder for this expression\n folder = self.config_folder + '/' + filename\n abr_control.utils.os_utils.makedirs(folder)\n\n if self.use_cython is True:\n # binaries saved by specifying tempdir parameter\n function = autowrap(expression, backend=\"cython\",\n args=parameters, tempdir=folder)\n function = sp.lambdify(parameters, expression, \"numpy\")\n\n return function","def get_real_function( this, fn):\n\t\treturn this._get_native_function(fn)","def generate(self):\n return self.gen.generate()","def code(self):\n if not self._code:\n filename = '<fluxtools function %s>' % self.tag\n self._code = compile(self.math, filename, mode='eval')\n return self._code","def for_function(self, func):\n return self.for_pysig(utils.pysignature(func))","def createFunctionTerm(self):\n return _libsbml.Transition_createFunctionTerm(self)","def _make_callable(func):\n try:\n return func.evaluator()\n except AttributeError:\n return func","def _create_function(self, expr):\n bb_entry = self.fn.append_basic_block('entry')\n builder = ll.IRBuilder(bb_entry)\n\n lj = LLVMJitPrinter(self.module, builder, self.fn,\n func_arg_map=self.param_dict)\n\n ret = self._convert_expr(lj, expr)\n lj.builder.ret(self._wrap_return(lj, ret))\n\n strmod = str(self.module)\n return strmod","def fortran_function(self) -> str:\n return ''.join([i.fortran_function() for i in self.instances])","def make_c_function_stubs(self):\n fn =\\\n\"\"\"{rettype} {fnname}({args}){{\n {rettype} ret;\n\n ret = {cast_and_deref}___madz_LANG_python_OUTPUT.{nodename}({argnames});\n\n return ret;\n}}\n\n\"\"\"\n fn_no_return =\\\n\"\"\"{rettype} {fnname}({args}){{\n ___madz_LANG_python_OUTPUT.{nodename}({argnames});\n return;\n}}\n\n\"\"\"\n res = \"\"\n c_gen = c_wrapgen.CGenerator([],\"\", self.description)\n for node in self.description.definitions():\n if isinstance(node.type.get_type(), pdl.TypeFunction):\n fragments = {\n \"maybe_parentheses\": \")\" if isinstance(node.type.return_type.get_type(),pdl.TypeStruct) else \"\",\n \"cast_and_deref\": self.make_c_cast_deref_string(c_gen, node.type.return_type),\n \"rettype\": c_gen.gen_type_string(\"\", node.type.return_type),\n \"fnname\": \"___madz_LANG_python_FN_\" + node.name,\n \"nodename\": node.name,\n \"args\": \",\".join(map(\n lambda a: c_gen.gen_type_string(a.name, a.type),\n node.type.args)),\n \"argnames\":\",\".join(map(\n lambda a: a.name,\n node.type.args))\n }\n res += (fn if not isinstance(node.type.return_type, pdl.TypeTypeNone) else fn_no_return).format(**fragments)\n return res","def get_function(self):\n return SSAFunction(self.get_graph())","def create_function(self, function):\n if function.body:\n self.create_function_internal(function)\n else:\n self.create_function_external(function)","def generate(self):\n pass","def f(self):\n return self._f","def __def_function__():\n pass","def new_generator(self):\n return self.generator_function(*self.args, **self.kwargs)","def lin_o_func(self):\n return self.hx","def __call__(self, *args, **kwargs):\n return function(args, addtional_info)","def createFunctionDefinition(self):\n return _libsbml.Model_createFunctionDefinition(self)","def getFunction(self, key: long) -> ghidra.program.model.listing.Function:\n ...","def make_score_fn(self):\n return self._score_fn","def retfun():\r\n return fn(*args, **kwargs)","def __get_function(self):\n return random.choice(self.FUNCTIONS)","def fortran_function(self) -> str:\n if self.f_override is not None:\n return indent(\n self.f_override.replace('$CLASSNAME$', self.class_name).replace(\n \"$C_PREFIX$\", self.c_prefix).replace(\n \"$F_PREFIX$\", self.f_prefix),\n 4*' ')\n\n result = ''\n\n # declaration\n func_name = '{}_{}_{}'.format(\n self.f_prefix, self.class_name, self.name)\n in_parameters = self._f_in_parameters()\n return_type, out_parameters = self._f_out_parameters()\n if self.may_throw:\n out_parameters.append(('integer, optional', 'err_code'))\n out_parameters.append(('character(:), allocatable, optional',\n 'err_msg'))\n\n all_parameters = in_parameters + out_parameters\n arg_list = ', &\\n'.join([par_name for _, par_name in all_parameters])\n arg_ilist = indent(arg_list, 8*' ')\n if return_type != '':\n result += 'function {}( &\\n{})\\n'.format(func_name, arg_ilist)\n else:\n result += 'subroutine {}( &\\n{})\\n'.format(func_name, arg_ilist)\n\n # parameter declarations\n result += ' implicit none\\n'\n for par_type, par_name in in_parameters:\n result += ' {}, intent(in) :: {}\\n'.format(\n par_type, par_name)\n for par_type, par_name in out_parameters:\n result += ' {}, intent(out) :: {}\\n'.format(par_type, par_name)\n if return_type != '':\n result += ' {} :: {}\\n'.format(return_type, func_name)\n result += '\\n'\n\n # variable declarations\n c_return_type, fi_out_parameters = self._fi_out_parameters()\n if c_return_type:\n result += ' {} :: ret_val\\n'.format(c_return_type)\n for par_type, par_name in fi_out_parameters:\n result += ' {} :: {}\\n'.format(par_type, par_name)\n for par_type, par_name in self.ret_type.f_aux_variables():\n result += ' {} :: {}\\n'.format(par_type, par_name)\n if self.may_throw:\n result += ' integer (c_int) :: err_code_v\\n'\n result += ' type (c_ptr) :: err_msg_v\\n'\n result += ' integer (c_size_t) :: err_msg_len_v\\n'\n result += ' character (c_char), dimension(:), pointer :: err_msg_f\\n'\n result += ' character(:), allocatable :: err_msg_p\\n'\n result += ' integer (c_size_t) :: err_msg_i\\n'\n if c_return_type or fi_out_parameters or self.may_throw:\n result += '\\n'\n\n # convert input\n args = [param.f_chain_arg() for param in self.params]\n args += [par_name for _, par_name in fi_out_parameters]\n if self.may_throw:\n args += ['err_code_v', 'err_msg_v', 'err_msg_len_v']\n arg_str = ', &\\n'.join([8*' ' + arg for arg in args])\n\n # call C function\n fc_func_name = '{}_{}_{}_'.format(\n self.c_prefix, self.class_name, self.name)\n chain_call = self.fc_chain_call(\n ns_prefix=self.c_prefix, class_name=self.class_name,\n fc_func_name=fc_func_name, fc_args=arg_str)\n result_name = ''\n if return_type != '':\n result_name = func_name\n elif out_parameters:\n result_name = out_parameters[0][1]\n result += self.ret_type.f_call_c('ret_val', chain_call)\n\n # handle errors if necessary\n if self.may_throw:\n # Note: I tried to factor this out into a function, but Fortran\n # makes that near-impossible. Since we're generating anyway, it's\n # not really duplication, so leave it as is.\n result += indent(dedent(f\"\"\"\\\n if (err_code_v .ne. 0) then\n if (present(err_code)) then\n err_code = err_code_v\n if (present(err_msg)) then\n call c_f_pointer(err_msg_v, err_msg_f, (/err_msg_len_v/))\n allocate (character(err_msg_len_v) :: err_msg)\n do err_msg_i = 1, err_msg_len_v\n err_msg(err_msg_i:err_msg_i) = err_msg_f(err_msg_i)\n end do\n end if\n {dedent(\n self.ret_type.f_return_dummy_result(result_name))}\n return\n else\n call c_f_pointer(err_msg_v, err_msg_f, (/err_msg_len_v/))\n allocate (character(err_msg_len_v) :: err_msg_p)\n do err_msg_i = 1, err_msg_len_v\n err_msg_p(err_msg_i:err_msg_i) = err_msg_f(err_msg_i)\n end do\n print *, err_msg_p\n stop\n end if\n else\n if (present(err_code)) then\n err_code = 0\n end if\n end if\n\n \"\"\"), 4*' ')\n\n # convert and return result\n result += self.ret_type.f_return_result(result_name, 'ret_val')\n\n # end\n if return_type != '':\n result += 'end function {}\\n\\n'.format(func_name)\n else:\n result += 'end subroutine {}\\n\\n'.format(func_name)\n return indent(result, 4*' ')","def function_uuid():\r\n yield uuid.uuid4()","def compile_function(self, function, arguments):","def build_pfunc(cls, representation):\n if ut.is_str(representation):\n try:\n func = eval(representation)\n except:\n bf = 'cls.build_pfunc('\n af = ')'\n st = ut.parse_enclose_with_counter(representation , before = bf, after = af)\n func = eval(st)\n \n elif ut.is_dico(representation):\n name_func = representation['name_func']\n func = eval(name_func)(**representation)\n \n else:\n raise SystemError(\"build_custom_func can build a function from an \"\n \"object of tye {0}\".format(cls.__class__))\n \n return func","def relay_to_tir(name, func):\n return GenerateTIR(name).generate_tir(func)","def function(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"function\")","def function(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"function\")","def function(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"function\")","def function_maker(self, i, o, m, *args, **kwargs):\r\n assert m is self\r\n return _Maker(i, o, self.optimizer, self, *args, **kwargs)","def build_model_fn(self):","def func(f):\n return func_custom(f.func_name)(f)","def make_main_function(self):\n\t\tself.main = self.tokens.get_joined()\n\t\tfor func in self.func_dict:\n\t\t\tself.main = self.main.replace(self.func_dict[func], func)","def GenerateNormalFunction(n):\n return eval('lambda a: %s' % GenerateNormalExpression(n))","def function_generator(decorated_function):\n\n def extended_func(*args, **kwargs):\n \"\"\"\n The result function, that wraps decorated function.\n \"\"\"\n return number * decorated_function(*args, **kwargs)\n\n return extended_func","def get_function(self):\n return self.element.get_basis_functions()[self.n]","def _wrap_in_generator(func, source, namer, overload):\n\n nonlocals = []\n\n for var in six.get_function_code(func).co_freevars:\n # We must generate dummy vars so the generated function has the same closure\n # as the original function.\n free_template = 'var = None'\n nonlocal_node = templates.replace(free_template, var=var)\n nonlocals.extend(nonlocal_node)\n\n gen_fun_name = namer.new_symbol('gen_fun', set())\n template = \"\"\"\n def gen_fun(overload):\n nonlocals\n\n program\n\n return f_name\n \"\"\"\n\n ret = templates.replace(\n template,\n gen_fun=gen_fun_name,\n nonlocals=nonlocals,\n overload=overload.symbol_name,\n program=source,\n f_name=func.__name__)\n\n converted_module, _ = parsing.ast_to_object(ret)\n outer_func = getattr(converted_module, gen_fun_name)\n return outer_func(overload.module)","def firstFunction(self):","def get_function(self):\n return Gumtree.gumtree.getFunction()","def generate(self):\n pass","def generate(self):\n pass","def generate(self):\n pass","def __compile__(self) -> types.FunctionType:\n code = {}\n exec(compile(self.__build_method__(), '<string>', 'exec'), code)\n return code[\"solve\"]","def fn(self):\n return \"Hello\"","def get_a_func(self, is_training=False, reuse=False):\n return functools.partial(self.a_func,\n num_actions=self._action_size,\n scope='a_func',\n reuse=reuse,\n is_training=is_training)","def _random_function(self, random_state):\n return random_state.rand","def __call__(self, function: FuncSpeechArg):\n self._add_attr(function)\n return function","def _gen_code(self):\r\n #TODO: maybe generate one C function only to save compile time? Also easier to take that as a basis and hand craft other covariances??\r\n\r\n #generate c functions from sympy objects \r\n argument_sequence = self._sp_x+self._sp_z+self._sp_theta\r\n code_list = [('k',self._sp_k)]\r\n # gradients with respect to covariance input\r\n code_list += [('dk_d%s'%x.name,dx) for x,dx in zip(self._sp_x,self._sp_dk_dx)]\r\n # gradient with respect to parameters\r\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta,self._sp_dk_dtheta)]\r\n # gradient with respect to multiple output parameters\r\n if self.output_dim > 1:\r\n argument_sequence += self._sp_theta_i + self._sp_theta_j\r\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta_i,self._sp_dk_dtheta_i)]\r\n (foo_c,self._function_code), (foo_h,self._function_header) = \\\r\n codegen(code_list, \"C\",'foobar',argument_sequence=argument_sequence)\r\n #put the header file where we can find it\r\n f = file(os.path.join(tempfile.gettempdir(),'foobar.h'),'w')\r\n f.write(self._function_header)\r\n f.close()\r\n\r\n # Substitute any known derivatives which sympy doesn't compute\r\n self._function_code = re.sub('DiracDelta\\(.+?,.+?\\)','0.0',self._function_code)\r\n\r\n\r\n ############################################################\r\n # This is the basic argument construction for the C code. #\r\n ############################################################\r\n \r\n arg_list = ([\"X2(i, %s)\"%x.name[2:] for x in self._sp_x]\r\n + [\"Z2(j, %s)\"%z.name[2:] for z in self._sp_z])\r\n\r\n # for multiple outputs need to also provide these arguments reversed.\r\n if self.output_dim>1:\r\n reverse_arg_list = list(arg_list)\r\n reverse_arg_list.reverse()\r\n\r\n # Add in any 'shared' parameters to the list.\r\n param_arg_list = [shared_params.name for shared_params in self._sp_theta]\r\n arg_list += param_arg_list\r\n\r\n precompute_list=[]\r\n if self.output_dim > 1:\r\n reverse_arg_list+=list(param_arg_list)\r\n split_param_arg_list = [\"%s1(%s)\"%(theta.name[:-2].upper(),index) for index in ['ii', 'jj'] for theta in self._sp_theta_i]\r\n split_param_reverse_arg_list = [\"%s1(%s)\"%(theta.name[:-2].upper(),index) for index in ['jj', 'ii'] for theta in self._sp_theta_i]\r\n arg_list += split_param_arg_list\r\n reverse_arg_list += split_param_reverse_arg_list\r\n # Extract the right output indices from the inputs.\r\n c_define_output_indices = [' '*16 + \"int %s=(int)%s(%s, %i);\"%(index, var, index2, self.input_dim-1) for index, var, index2 in zip(['ii', 'jj'], ['X2', 'Z2'], ['i', 'j'])]\r\n precompute_list += c_define_output_indices\r\n reverse_arg_string = \", \".join(reverse_arg_list)\r\n arg_string = \", \".join(arg_list)\r\n precompute_string = \"\\n\".join(precompute_list)\r\n\r\n # Code to compute argments string needed when only X is provided.\r\n X_arg_string = re.sub('Z','X',arg_string)\r\n # Code to compute argument string when only diagonal is required.\r\n diag_arg_string = re.sub('int jj','//int jj',X_arg_string)\r\n diag_arg_string = re.sub('j','i',diag_arg_string)\r\n if precompute_string == '':\r\n # if it's not multioutput, the precompute strings are set to zero\r\n diag_precompute_string = ''\r\n diag_precompute_replace = ''\r\n else:\r\n # for multioutput we need to extract the index of the output form the input.\r\n diag_precompute_string = precompute_list[0]\r\n diag_precompute_replace = precompute_list[1]\r\n \r\n\r\n # Here's the code to do the looping for K\r\n self._K_code =\\\r\n \"\"\"\r\n // _K_code\r\n // Code for computing the covariance function.\r\n int i;\r\n int j;\r\n int N = target_array->dimensions[0];\r\n int num_inducing = target_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N;i++){\r\n for (j=0;j<num_inducing;j++){\r\n%s\r\n //target[i*num_inducing+j] = \r\n TARGET2(i, j) += k(%s);\r\n }\r\n }\r\n %s\r\n \"\"\"%(precompute_string,arg_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n\r\n self._K_code_X = \"\"\"\r\n // _K_code_X\r\n // Code for computing the covariance function.\r\n int i;\r\n int j;\r\n int N = target_array->dimensions[0];\r\n int num_inducing = target_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N;i++){\r\n %s // int ii=(int)X2(i, 1);\r\n TARGET2(i, i) += k(%s);\r\n for (j=0;j<i;j++){\r\n %s //int jj=(int)X2(j, 1);\r\n double kval = k(%s); //double kval = k(X2(i, 0), shared_lengthscale, LENGTHSCALE1(ii), SCALE1(ii));\r\n TARGET2(i, j) += kval;\r\n TARGET2(j, i) += kval;\r\n }\r\n }\r\n /*%s*/\r\n \"\"\"%(diag_precompute_string, diag_arg_string, re.sub('Z2', 'X2', diag_precompute_replace), X_arg_string,str(self._sp_k)) #adding a string representation forces recompile when needed\r\n\r\n # Code to do the looping for Kdiag\r\n self._Kdiag_code =\\\r\n \"\"\"\r\n // _Kdiag_code\r\n // Code for computing diagonal of covariance function.\r\n int i;\r\n int N = target_array->dimensions[0];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for\r\n for (i=0;i<N;i++){\r\n %s\r\n //target[i] =\r\n TARGET1(i)=k(%s);\r\n }\r\n %s\r\n \"\"\"%(diag_precompute_string,diag_arg_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n\r\n # Code to compute gradients\r\n grad_func_list = []\r\n if self.output_dim>1:\r\n grad_func_list += c_define_output_indices\r\n grad_func_list += [' '*16 + 'TARGET1(%i+ii) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, arg_string) for i, theta in enumerate(self._sp_theta_i)]\r\n grad_func_list += [' '*16 + 'TARGET1(%i+jj) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, reverse_arg_string) for i, theta in enumerate(self._sp_theta_i)]\r\n grad_func_list += ([' '*16 + 'TARGET1(%i) += PARTIAL2(i, j)*dk_d%s(%s);'%(i,theta.name,arg_string) for i,theta in enumerate(self._sp_theta)])\r\n grad_func_string = '\\n'.join(grad_func_list) \r\n\r\n self._dK_dtheta_code =\\\r\n \"\"\"\r\n // _dK_dtheta_code\r\n // Code for computing gradient of covariance with respect to parameters.\r\n int i;\r\n int j;\r\n int N = partial_array->dimensions[0];\r\n int num_inducing = partial_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N;i++){\r\n for (j=0;j<num_inducing;j++){\r\n%s\r\n }\r\n }\r\n %s\r\n \"\"\"%(grad_func_string,\"/*\"+str(self._sp_k)+\"*/\") # adding a string representation forces recompile when needed\r\n\r\n\r\n # Code to compute gradients for Kdiag TODO: needs clean up\r\n diag_grad_func_string = re.sub('Z','X',grad_func_string,count=0)\r\n diag_grad_func_string = re.sub('int jj','//int jj',diag_grad_func_string)\r\n diag_grad_func_string = re.sub('j','i',diag_grad_func_string)\r\n diag_grad_func_string = re.sub('PARTIAL2\\(i, i\\)','PARTIAL1(i)',diag_grad_func_string)\r\n self._dKdiag_dtheta_code =\\\r\n \"\"\"\r\n // _dKdiag_dtheta_code\r\n // Code for computing gradient of diagonal with respect to parameters.\r\n int i;\r\n int N = partial_array->dimensions[0];\r\n int input_dim = X_array->dimensions[1];\r\n for (i=0;i<N;i++){\r\n %s\r\n }\r\n %s\r\n \"\"\"%(diag_grad_func_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n\r\n # Code for gradients wrt X, TODO: may need to deal with special case where one input is actually an output.\r\n gradX_func_list = []\r\n if self.output_dim>1:\r\n gradX_func_list += c_define_output_indices\r\n gradX_func_list += [\"TARGET2(i, %i) += PARTIAL2(i, j)*dk_dx_%i(%s);\"%(q,q,arg_string) for q in range(self._real_input_dim)]\r\n gradX_func_string = \"\\n\".join(gradX_func_list)\r\n\r\n self._dK_dX_code = \\\r\n \"\"\"\r\n // _dK_dX_code\r\n // Code for computing gradient of covariance with respect to inputs.\r\n int i;\r\n int j;\r\n int N = partial_array->dimensions[0];\r\n int num_inducing = partial_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N; i++){\r\n for (j=0; j<num_inducing; j++){\r\n %s\r\n }\r\n }\r\n %s\r\n \"\"\"%(gradX_func_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n \r\n\r\n diag_gradX_func_string = re.sub('Z','X',gradX_func_string,count=0)\r\n diag_gradX_func_string = re.sub('int jj','//int jj',diag_gradX_func_string)\r\n diag_gradX_func_string = re.sub('j','i',diag_gradX_func_string)\r\n diag_gradX_func_string = re.sub('PARTIAL2\\(i, i\\)','2*PARTIAL1(i)',diag_gradX_func_string)\r\n\r\n # Code for gradients of Kdiag wrt X\r\n self._dKdiag_dX_code= \\\r\n \"\"\"\r\n // _dKdiag_dX_code\r\n // Code for computing gradient of diagonal with respect to inputs.\r\n int N = partial_array->dimensions[0];\r\n int input_dim = X_array->dimensions[1];\r\n for (int i=0;i<N; i++){\r\n %s\r\n }\r\n %s\r\n \"\"\"%(diag_gradX_func_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a\r\n # string representation forces recompile when needed Get rid\r\n # of Zs in argument for diagonal. TODO: Why wasn't\r\n # diag_func_string called here? Need to check that.\r\n #self._dKdiag_dX_code = self._dKdiag_dX_code.replace('Z[j', 'X[i')\r\n\r\n # Code to use when only X is provided. \r\n self._dK_dtheta_code_X = self._dK_dtheta_code.replace('Z[', 'X[')\r\n self._dK_dX_code_X = self._dK_dX_code.replace('Z[', 'X[').replace('+= PARTIAL2(', '+= 2*PARTIAL2(') \r\n self._dK_dtheta_code_X = self._dK_dtheta_code_X.replace('Z2(', 'X2(')\r\n self._dK_dX_code_X = self._dK_dX_code_X.replace('Z2(', 'X2(')\r\n\r\n\r\n #TODO: insert multiple functions here via string manipulation\r\n #TODO: similar functions for psi_stats\r","def a_function_of_mine():\n return 'result'","def python_function(self):\n return self._python_function # pylint: disable=protected-access","def function(self):\n return self.devicefuncs[self._funcname]","def func(cls):\n return cls.get_wrapper()(cls.callable)","def special_def(self, form):\n if not len(form) >= 3:\n raise SyntaxError(\"Not enough forms in %s\" % form)\n if not isinstance(form[1], Form):\n raise SyntaxError(\"Expected a list of [funname args...]\")\n\n doc, code = self._getDocAndCode(form[2:])\n #print \"GOT\", code\n #code.nodes[-1] = ast.Return(code.nodes[-1])\n args = [x.name for x in form[1][1:]]\n \n magicode = self._getMagicCodeForArgs(args)\n \n return ast.Function(None, form[1][0].name, args, [], magicode, doc, code)","def gen_vee_func(self):\n dual_func = self.dual_func\n omt_func = self.omt_func\n @numba.njit\n def vee(aval, bval):\n return dual_func(omt_func(dual_func(aval), dual_func(bval)))\n return vee","def function(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"function\")"],"string":"[\n \"def getFunction(self) -> ghidra.program.model.listing.Function:\\n ...\",\n \"def gen_function(self, function):\\n if function.body:\\n self.gen_function_def(function)\",\n \"def func ( self ) :\\n return self.__func\",\n \"def func ( self ) :\\n return self.__func\",\n \"def __call__(self):\\n return self.generate()\",\n \"def RandomFunction(self):\\r\\n return self._random_fn\",\n \"def __call__(fun_name):\",\n \"def _func(self):\\n return self._get_flint_func(self.domain)\",\n \"def function(self):\\n raise NotImplementedError\",\n \"def _gen_closure(fnc,arg):\\n return lambda s: fnc(arg)\",\n \"def get_function(self):\\n return subs(self.f.get_function(), self.sub_pre, self.sub_post)\",\n \"def fn():\",\n \"def get_gen_loop_fun(param_dict, fun_dict):\\n def f(x_pl, hid_pl, count, f_state, eps_z, eps_x):\\n return gen_loop(x_pl, hid_pl, count, f_state, eps_z, eps_x, param_dict, fun_dict)\\n return f\",\n \"def generate():\",\n \"def make_transform_fn(self, ):\\n return self._transform_fn\",\n \"def createTransformFunc(self):\\n raise NotImplementedError()\",\n \"def get_transform_fn():\",\n \"def generate(self, namespace: Optional[str], template: str, func: Callable, call_args: Dict) -> str:\",\n \"def function(self):\\n return self.generator.module.neumannz\",\n \"def func():\",\n \"def function(self):\\n return self.generator.module.neumannx\",\n \"def get_function(self):\\n raise NotImplementedError()\",\n \"def function(self):\\n return self.generator.module.neumanny\",\n \"def getFunction(self, name: unicode) -> ghidra.program.model.listing.Function:\\n ...\",\n \"def _create_function(self, expr):\\n bb_entry = self.fn.append_basic_block('entry')\\n builder = ll.IRBuilder(bb_entry)\\n\\n lj = LLVMJitCallbackPrinter(self.module, builder, self.fn,\\n func_arg_map=self.param_dict)\\n\\n ret = self._convert_expr(lj, expr)\\n\\n if self.signature.ret_arg:\\n output_fp_ptr = builder.bitcast(self.fn.args[self.signature.ret_arg],\\n ll.PointerType(self.fp_type))\\n for i, val in enumerate(ret):\\n index = ll.Constant(ll.IntType(32), i)\\n output_array_ptr = builder.gep(output_fp_ptr, [index])\\n builder.store(val, output_array_ptr)\\n builder.ret(ll.Constant(ll.IntType(32), 0)) # return success\\n else:\\n lj.builder.ret(self._wrap_return(lj, ret))\\n\\n strmod = str(self.module)\\n return strmod\",\n \"def _generate_fun(self, name, specstr, resname, specnames, docodeinserts=False):\\n\\n fdef = self._fn_template.format(\\n name=name,\\n start=self._format_user_code(self.opts['start']) if docodeinserts else '',\\n spec=specstr,\\n end=self._format_user_code(self.opts['end']) if docodeinserts else '',\\n result=makeParList(range(len(specnames)), resname)\\n )\\n return '\\\\n'.join([s for s in fdef.split('\\\\n') if s]) + '\\\\n'\",\n \"def generate(self):\",\n \"def __call__(self):\\n return self.fn()\",\n \"def getFunction(self):\\n return lambda x: self.slope * x + self.ordinate\",\n \"def get_decorated_function(self):\",\n \"def convert_function(self, access_modifier, return_type, func_name, params):\\n\\n # Run super func_name\\n access_modifier, return_type, func_name, params = \\\\\\n super().convert_function(access_modifier, return_type,\\n func_name, params)\\n\\n # Make and return processed function definition\\n return [self.make_function_definition(return_type, func_name, params)], []\",\n \"def make_function(self):\\n result = {}\\n x0 = 0\\n for i, x in enumerate(self.step_vals):\\n vals_range = xrange(x0, x)\\n for k in vals_range:\\n result[k] = i\\n x0 = x\\n self.function = result\",\n \"def function(self):\\n return self.generator.module.neumann\",\n \"def fn(self):\\n return self._fn\",\n \"def getCallable():\",\n \"def view_function(self,v):\\n return v\",\n \"def function(self, name):\\n return function_documentor(name)\",\n \"def generate(self):\\r\\n raise NotImplementedError\",\n \"def GenerateSpecialFunction(n):\\n return eval('lambda a: %s' % GenerateSpecialExpression(n))\",\n \"def createFunction(self, entryPoint: ghidra.program.model.address.Address, name: unicode) -> ghidra.program.model.listing.Function:\\n ...\",\n \"def f():\",\n \"def f():\",\n \"def get_now_func():\\n return _now_func[0]\",\n \"def cpp_function(self):\",\n \"def _generate_and_save_function(self, filename, expression, parameters):\\n\\n # check for / create the save folder for this expression\\n folder = self.config_folder + '/' + filename\\n abr_control.utils.os_utils.makedirs(folder)\\n\\n if self.use_cython is True:\\n # binaries saved by specifying tempdir parameter\\n function = autowrap(expression, backend=\\\"cython\\\",\\n args=parameters, tempdir=folder)\\n function = sp.lambdify(parameters, expression, \\\"numpy\\\")\\n\\n return function\",\n \"def get_real_function( this, fn):\\n\\t\\treturn this._get_native_function(fn)\",\n \"def generate(self):\\n return self.gen.generate()\",\n \"def code(self):\\n if not self._code:\\n filename = '<fluxtools function %s>' % self.tag\\n self._code = compile(self.math, filename, mode='eval')\\n return self._code\",\n \"def for_function(self, func):\\n return self.for_pysig(utils.pysignature(func))\",\n \"def createFunctionTerm(self):\\n return _libsbml.Transition_createFunctionTerm(self)\",\n \"def _make_callable(func):\\n try:\\n return func.evaluator()\\n except AttributeError:\\n return func\",\n \"def _create_function(self, expr):\\n bb_entry = self.fn.append_basic_block('entry')\\n builder = ll.IRBuilder(bb_entry)\\n\\n lj = LLVMJitPrinter(self.module, builder, self.fn,\\n func_arg_map=self.param_dict)\\n\\n ret = self._convert_expr(lj, expr)\\n lj.builder.ret(self._wrap_return(lj, ret))\\n\\n strmod = str(self.module)\\n return strmod\",\n \"def fortran_function(self) -> str:\\n return ''.join([i.fortran_function() for i in self.instances])\",\n \"def make_c_function_stubs(self):\\n fn =\\\\\\n\\\"\\\"\\\"{rettype} {fnname}({args}){{\\n {rettype} ret;\\n\\n ret = {cast_and_deref}___madz_LANG_python_OUTPUT.{nodename}({argnames});\\n\\n return ret;\\n}}\\n\\n\\\"\\\"\\\"\\n fn_no_return =\\\\\\n\\\"\\\"\\\"{rettype} {fnname}({args}){{\\n ___madz_LANG_python_OUTPUT.{nodename}({argnames});\\n return;\\n}}\\n\\n\\\"\\\"\\\"\\n res = \\\"\\\"\\n c_gen = c_wrapgen.CGenerator([],\\\"\\\", self.description)\\n for node in self.description.definitions():\\n if isinstance(node.type.get_type(), pdl.TypeFunction):\\n fragments = {\\n \\\"maybe_parentheses\\\": \\\")\\\" if isinstance(node.type.return_type.get_type(),pdl.TypeStruct) else \\\"\\\",\\n \\\"cast_and_deref\\\": self.make_c_cast_deref_string(c_gen, node.type.return_type),\\n \\\"rettype\\\": c_gen.gen_type_string(\\\"\\\", node.type.return_type),\\n \\\"fnname\\\": \\\"___madz_LANG_python_FN_\\\" + node.name,\\n \\\"nodename\\\": node.name,\\n \\\"args\\\": \\\",\\\".join(map(\\n lambda a: c_gen.gen_type_string(a.name, a.type),\\n node.type.args)),\\n \\\"argnames\\\":\\\",\\\".join(map(\\n lambda a: a.name,\\n node.type.args))\\n }\\n res += (fn if not isinstance(node.type.return_type, pdl.TypeTypeNone) else fn_no_return).format(**fragments)\\n return res\",\n \"def get_function(self):\\n return SSAFunction(self.get_graph())\",\n \"def create_function(self, function):\\n if function.body:\\n self.create_function_internal(function)\\n else:\\n self.create_function_external(function)\",\n \"def generate(self):\\n pass\",\n \"def f(self):\\n return self._f\",\n \"def __def_function__():\\n pass\",\n \"def new_generator(self):\\n return self.generator_function(*self.args, **self.kwargs)\",\n \"def lin_o_func(self):\\n return self.hx\",\n \"def __call__(self, *args, **kwargs):\\n return function(args, addtional_info)\",\n \"def createFunctionDefinition(self):\\n return _libsbml.Model_createFunctionDefinition(self)\",\n \"def getFunction(self, key: long) -> ghidra.program.model.listing.Function:\\n ...\",\n \"def make_score_fn(self):\\n return self._score_fn\",\n \"def retfun():\\r\\n return fn(*args, **kwargs)\",\n \"def __get_function(self):\\n return random.choice(self.FUNCTIONS)\",\n \"def fortran_function(self) -> str:\\n if self.f_override is not None:\\n return indent(\\n self.f_override.replace('$CLASSNAME$', self.class_name).replace(\\n \\\"$C_PREFIX$\\\", self.c_prefix).replace(\\n \\\"$F_PREFIX$\\\", self.f_prefix),\\n 4*' ')\\n\\n result = ''\\n\\n # declaration\\n func_name = '{}_{}_{}'.format(\\n self.f_prefix, self.class_name, self.name)\\n in_parameters = self._f_in_parameters()\\n return_type, out_parameters = self._f_out_parameters()\\n if self.may_throw:\\n out_parameters.append(('integer, optional', 'err_code'))\\n out_parameters.append(('character(:), allocatable, optional',\\n 'err_msg'))\\n\\n all_parameters = in_parameters + out_parameters\\n arg_list = ', &\\\\n'.join([par_name for _, par_name in all_parameters])\\n arg_ilist = indent(arg_list, 8*' ')\\n if return_type != '':\\n result += 'function {}( &\\\\n{})\\\\n'.format(func_name, arg_ilist)\\n else:\\n result += 'subroutine {}( &\\\\n{})\\\\n'.format(func_name, arg_ilist)\\n\\n # parameter declarations\\n result += ' implicit none\\\\n'\\n for par_type, par_name in in_parameters:\\n result += ' {}, intent(in) :: {}\\\\n'.format(\\n par_type, par_name)\\n for par_type, par_name in out_parameters:\\n result += ' {}, intent(out) :: {}\\\\n'.format(par_type, par_name)\\n if return_type != '':\\n result += ' {} :: {}\\\\n'.format(return_type, func_name)\\n result += '\\\\n'\\n\\n # variable declarations\\n c_return_type, fi_out_parameters = self._fi_out_parameters()\\n if c_return_type:\\n result += ' {} :: ret_val\\\\n'.format(c_return_type)\\n for par_type, par_name in fi_out_parameters:\\n result += ' {} :: {}\\\\n'.format(par_type, par_name)\\n for par_type, par_name in self.ret_type.f_aux_variables():\\n result += ' {} :: {}\\\\n'.format(par_type, par_name)\\n if self.may_throw:\\n result += ' integer (c_int) :: err_code_v\\\\n'\\n result += ' type (c_ptr) :: err_msg_v\\\\n'\\n result += ' integer (c_size_t) :: err_msg_len_v\\\\n'\\n result += ' character (c_char), dimension(:), pointer :: err_msg_f\\\\n'\\n result += ' character(:), allocatable :: err_msg_p\\\\n'\\n result += ' integer (c_size_t) :: err_msg_i\\\\n'\\n if c_return_type or fi_out_parameters or self.may_throw:\\n result += '\\\\n'\\n\\n # convert input\\n args = [param.f_chain_arg() for param in self.params]\\n args += [par_name for _, par_name in fi_out_parameters]\\n if self.may_throw:\\n args += ['err_code_v', 'err_msg_v', 'err_msg_len_v']\\n arg_str = ', &\\\\n'.join([8*' ' + arg for arg in args])\\n\\n # call C function\\n fc_func_name = '{}_{}_{}_'.format(\\n self.c_prefix, self.class_name, self.name)\\n chain_call = self.fc_chain_call(\\n ns_prefix=self.c_prefix, class_name=self.class_name,\\n fc_func_name=fc_func_name, fc_args=arg_str)\\n result_name = ''\\n if return_type != '':\\n result_name = func_name\\n elif out_parameters:\\n result_name = out_parameters[0][1]\\n result += self.ret_type.f_call_c('ret_val', chain_call)\\n\\n # handle errors if necessary\\n if self.may_throw:\\n # Note: I tried to factor this out into a function, but Fortran\\n # makes that near-impossible. Since we're generating anyway, it's\\n # not really duplication, so leave it as is.\\n result += indent(dedent(f\\\"\\\"\\\"\\\\\\n if (err_code_v .ne. 0) then\\n if (present(err_code)) then\\n err_code = err_code_v\\n if (present(err_msg)) then\\n call c_f_pointer(err_msg_v, err_msg_f, (/err_msg_len_v/))\\n allocate (character(err_msg_len_v) :: err_msg)\\n do err_msg_i = 1, err_msg_len_v\\n err_msg(err_msg_i:err_msg_i) = err_msg_f(err_msg_i)\\n end do\\n end if\\n {dedent(\\n self.ret_type.f_return_dummy_result(result_name))}\\n return\\n else\\n call c_f_pointer(err_msg_v, err_msg_f, (/err_msg_len_v/))\\n allocate (character(err_msg_len_v) :: err_msg_p)\\n do err_msg_i = 1, err_msg_len_v\\n err_msg_p(err_msg_i:err_msg_i) = err_msg_f(err_msg_i)\\n end do\\n print *, err_msg_p\\n stop\\n end if\\n else\\n if (present(err_code)) then\\n err_code = 0\\n end if\\n end if\\n\\n \\\"\\\"\\\"), 4*' ')\\n\\n # convert and return result\\n result += self.ret_type.f_return_result(result_name, 'ret_val')\\n\\n # end\\n if return_type != '':\\n result += 'end function {}\\\\n\\\\n'.format(func_name)\\n else:\\n result += 'end subroutine {}\\\\n\\\\n'.format(func_name)\\n return indent(result, 4*' ')\",\n \"def function_uuid():\\r\\n yield uuid.uuid4()\",\n \"def compile_function(self, function, arguments):\",\n \"def build_pfunc(cls, representation):\\n if ut.is_str(representation):\\n try:\\n func = eval(representation)\\n except:\\n bf = 'cls.build_pfunc('\\n af = ')'\\n st = ut.parse_enclose_with_counter(representation , before = bf, after = af)\\n func = eval(st)\\n \\n elif ut.is_dico(representation):\\n name_func = representation['name_func']\\n func = eval(name_func)(**representation)\\n \\n else:\\n raise SystemError(\\\"build_custom_func can build a function from an \\\"\\n \\\"object of tye {0}\\\".format(cls.__class__))\\n \\n return func\",\n \"def relay_to_tir(name, func):\\n return GenerateTIR(name).generate_tir(func)\",\n \"def function(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"function\\\")\",\n \"def function(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"function\\\")\",\n \"def function(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"function\\\")\",\n \"def function_maker(self, i, o, m, *args, **kwargs):\\r\\n assert m is self\\r\\n return _Maker(i, o, self.optimizer, self, *args, **kwargs)\",\n \"def build_model_fn(self):\",\n \"def func(f):\\n return func_custom(f.func_name)(f)\",\n \"def make_main_function(self):\\n\\t\\tself.main = self.tokens.get_joined()\\n\\t\\tfor func in self.func_dict:\\n\\t\\t\\tself.main = self.main.replace(self.func_dict[func], func)\",\n \"def GenerateNormalFunction(n):\\n return eval('lambda a: %s' % GenerateNormalExpression(n))\",\n \"def function_generator(decorated_function):\\n\\n def extended_func(*args, **kwargs):\\n \\\"\\\"\\\"\\n The result function, that wraps decorated function.\\n \\\"\\\"\\\"\\n return number * decorated_function(*args, **kwargs)\\n\\n return extended_func\",\n \"def get_function(self):\\n return self.element.get_basis_functions()[self.n]\",\n \"def _wrap_in_generator(func, source, namer, overload):\\n\\n nonlocals = []\\n\\n for var in six.get_function_code(func).co_freevars:\\n # We must generate dummy vars so the generated function has the same closure\\n # as the original function.\\n free_template = 'var = None'\\n nonlocal_node = templates.replace(free_template, var=var)\\n nonlocals.extend(nonlocal_node)\\n\\n gen_fun_name = namer.new_symbol('gen_fun', set())\\n template = \\\"\\\"\\\"\\n def gen_fun(overload):\\n nonlocals\\n\\n program\\n\\n return f_name\\n \\\"\\\"\\\"\\n\\n ret = templates.replace(\\n template,\\n gen_fun=gen_fun_name,\\n nonlocals=nonlocals,\\n overload=overload.symbol_name,\\n program=source,\\n f_name=func.__name__)\\n\\n converted_module, _ = parsing.ast_to_object(ret)\\n outer_func = getattr(converted_module, gen_fun_name)\\n return outer_func(overload.module)\",\n \"def firstFunction(self):\",\n \"def get_function(self):\\n return Gumtree.gumtree.getFunction()\",\n \"def generate(self):\\n pass\",\n \"def generate(self):\\n pass\",\n \"def generate(self):\\n pass\",\n \"def __compile__(self) -> types.FunctionType:\\n code = {}\\n exec(compile(self.__build_method__(), '<string>', 'exec'), code)\\n return code[\\\"solve\\\"]\",\n \"def fn(self):\\n return \\\"Hello\\\"\",\n \"def get_a_func(self, is_training=False, reuse=False):\\n return functools.partial(self.a_func,\\n num_actions=self._action_size,\\n scope='a_func',\\n reuse=reuse,\\n is_training=is_training)\",\n \"def _random_function(self, random_state):\\n return random_state.rand\",\n \"def __call__(self, function: FuncSpeechArg):\\n self._add_attr(function)\\n return function\",\n \"def _gen_code(self):\\r\\n #TODO: maybe generate one C function only to save compile time? Also easier to take that as a basis and hand craft other covariances??\\r\\n\\r\\n #generate c functions from sympy objects \\r\\n argument_sequence = self._sp_x+self._sp_z+self._sp_theta\\r\\n code_list = [('k',self._sp_k)]\\r\\n # gradients with respect to covariance input\\r\\n code_list += [('dk_d%s'%x.name,dx) for x,dx in zip(self._sp_x,self._sp_dk_dx)]\\r\\n # gradient with respect to parameters\\r\\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta,self._sp_dk_dtheta)]\\r\\n # gradient with respect to multiple output parameters\\r\\n if self.output_dim > 1:\\r\\n argument_sequence += self._sp_theta_i + self._sp_theta_j\\r\\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta_i,self._sp_dk_dtheta_i)]\\r\\n (foo_c,self._function_code), (foo_h,self._function_header) = \\\\\\r\\n codegen(code_list, \\\"C\\\",'foobar',argument_sequence=argument_sequence)\\r\\n #put the header file where we can find it\\r\\n f = file(os.path.join(tempfile.gettempdir(),'foobar.h'),'w')\\r\\n f.write(self._function_header)\\r\\n f.close()\\r\\n\\r\\n # Substitute any known derivatives which sympy doesn't compute\\r\\n self._function_code = re.sub('DiracDelta\\\\(.+?,.+?\\\\)','0.0',self._function_code)\\r\\n\\r\\n\\r\\n ############################################################\\r\\n # This is the basic argument construction for the C code. #\\r\\n ############################################################\\r\\n \\r\\n arg_list = ([\\\"X2(i, %s)\\\"%x.name[2:] for x in self._sp_x]\\r\\n + [\\\"Z2(j, %s)\\\"%z.name[2:] for z in self._sp_z])\\r\\n\\r\\n # for multiple outputs need to also provide these arguments reversed.\\r\\n if self.output_dim>1:\\r\\n reverse_arg_list = list(arg_list)\\r\\n reverse_arg_list.reverse()\\r\\n\\r\\n # Add in any 'shared' parameters to the list.\\r\\n param_arg_list = [shared_params.name for shared_params in self._sp_theta]\\r\\n arg_list += param_arg_list\\r\\n\\r\\n precompute_list=[]\\r\\n if self.output_dim > 1:\\r\\n reverse_arg_list+=list(param_arg_list)\\r\\n split_param_arg_list = [\\\"%s1(%s)\\\"%(theta.name[:-2].upper(),index) for index in ['ii', 'jj'] for theta in self._sp_theta_i]\\r\\n split_param_reverse_arg_list = [\\\"%s1(%s)\\\"%(theta.name[:-2].upper(),index) for index in ['jj', 'ii'] for theta in self._sp_theta_i]\\r\\n arg_list += split_param_arg_list\\r\\n reverse_arg_list += split_param_reverse_arg_list\\r\\n # Extract the right output indices from the inputs.\\r\\n c_define_output_indices = [' '*16 + \\\"int %s=(int)%s(%s, %i);\\\"%(index, var, index2, self.input_dim-1) for index, var, index2 in zip(['ii', 'jj'], ['X2', 'Z2'], ['i', 'j'])]\\r\\n precompute_list += c_define_output_indices\\r\\n reverse_arg_string = \\\", \\\".join(reverse_arg_list)\\r\\n arg_string = \\\", \\\".join(arg_list)\\r\\n precompute_string = \\\"\\\\n\\\".join(precompute_list)\\r\\n\\r\\n # Code to compute argments string needed when only X is provided.\\r\\n X_arg_string = re.sub('Z','X',arg_string)\\r\\n # Code to compute argument string when only diagonal is required.\\r\\n diag_arg_string = re.sub('int jj','//int jj',X_arg_string)\\r\\n diag_arg_string = re.sub('j','i',diag_arg_string)\\r\\n if precompute_string == '':\\r\\n # if it's not multioutput, the precompute strings are set to zero\\r\\n diag_precompute_string = ''\\r\\n diag_precompute_replace = ''\\r\\n else:\\r\\n # for multioutput we need to extract the index of the output form the input.\\r\\n diag_precompute_string = precompute_list[0]\\r\\n diag_precompute_replace = precompute_list[1]\\r\\n \\r\\n\\r\\n # Here's the code to do the looping for K\\r\\n self._K_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _K_code\\r\\n // Code for computing the covariance function.\\r\\n int i;\\r\\n int j;\\r\\n int N = target_array->dimensions[0];\\r\\n int num_inducing = target_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N;i++){\\r\\n for (j=0;j<num_inducing;j++){\\r\\n%s\\r\\n //target[i*num_inducing+j] = \\r\\n TARGET2(i, j) += k(%s);\\r\\n }\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(precompute_string,arg_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n\\r\\n self._K_code_X = \\\"\\\"\\\"\\r\\n // _K_code_X\\r\\n // Code for computing the covariance function.\\r\\n int i;\\r\\n int j;\\r\\n int N = target_array->dimensions[0];\\r\\n int num_inducing = target_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N;i++){\\r\\n %s // int ii=(int)X2(i, 1);\\r\\n TARGET2(i, i) += k(%s);\\r\\n for (j=0;j<i;j++){\\r\\n %s //int jj=(int)X2(j, 1);\\r\\n double kval = k(%s); //double kval = k(X2(i, 0), shared_lengthscale, LENGTHSCALE1(ii), SCALE1(ii));\\r\\n TARGET2(i, j) += kval;\\r\\n TARGET2(j, i) += kval;\\r\\n }\\r\\n }\\r\\n /*%s*/\\r\\n \\\"\\\"\\\"%(diag_precompute_string, diag_arg_string, re.sub('Z2', 'X2', diag_precompute_replace), X_arg_string,str(self._sp_k)) #adding a string representation forces recompile when needed\\r\\n\\r\\n # Code to do the looping for Kdiag\\r\\n self._Kdiag_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _Kdiag_code\\r\\n // Code for computing diagonal of covariance function.\\r\\n int i;\\r\\n int N = target_array->dimensions[0];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for\\r\\n for (i=0;i<N;i++){\\r\\n %s\\r\\n //target[i] =\\r\\n TARGET1(i)=k(%s);\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(diag_precompute_string,diag_arg_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n\\r\\n # Code to compute gradients\\r\\n grad_func_list = []\\r\\n if self.output_dim>1:\\r\\n grad_func_list += c_define_output_indices\\r\\n grad_func_list += [' '*16 + 'TARGET1(%i+ii) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, arg_string) for i, theta in enumerate(self._sp_theta_i)]\\r\\n grad_func_list += [' '*16 + 'TARGET1(%i+jj) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, reverse_arg_string) for i, theta in enumerate(self._sp_theta_i)]\\r\\n grad_func_list += ([' '*16 + 'TARGET1(%i) += PARTIAL2(i, j)*dk_d%s(%s);'%(i,theta.name,arg_string) for i,theta in enumerate(self._sp_theta)])\\r\\n grad_func_string = '\\\\n'.join(grad_func_list) \\r\\n\\r\\n self._dK_dtheta_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dK_dtheta_code\\r\\n // Code for computing gradient of covariance with respect to parameters.\\r\\n int i;\\r\\n int j;\\r\\n int N = partial_array->dimensions[0];\\r\\n int num_inducing = partial_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N;i++){\\r\\n for (j=0;j<num_inducing;j++){\\r\\n%s\\r\\n }\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(grad_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") # adding a string representation forces recompile when needed\\r\\n\\r\\n\\r\\n # Code to compute gradients for Kdiag TODO: needs clean up\\r\\n diag_grad_func_string = re.sub('Z','X',grad_func_string,count=0)\\r\\n diag_grad_func_string = re.sub('int jj','//int jj',diag_grad_func_string)\\r\\n diag_grad_func_string = re.sub('j','i',diag_grad_func_string)\\r\\n diag_grad_func_string = re.sub('PARTIAL2\\\\(i, i\\\\)','PARTIAL1(i)',diag_grad_func_string)\\r\\n self._dKdiag_dtheta_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dKdiag_dtheta_code\\r\\n // Code for computing gradient of diagonal with respect to parameters.\\r\\n int i;\\r\\n int N = partial_array->dimensions[0];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n for (i=0;i<N;i++){\\r\\n %s\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(diag_grad_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n\\r\\n # Code for gradients wrt X, TODO: may need to deal with special case where one input is actually an output.\\r\\n gradX_func_list = []\\r\\n if self.output_dim>1:\\r\\n gradX_func_list += c_define_output_indices\\r\\n gradX_func_list += [\\\"TARGET2(i, %i) += PARTIAL2(i, j)*dk_dx_%i(%s);\\\"%(q,q,arg_string) for q in range(self._real_input_dim)]\\r\\n gradX_func_string = \\\"\\\\n\\\".join(gradX_func_list)\\r\\n\\r\\n self._dK_dX_code = \\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dK_dX_code\\r\\n // Code for computing gradient of covariance with respect to inputs.\\r\\n int i;\\r\\n int j;\\r\\n int N = partial_array->dimensions[0];\\r\\n int num_inducing = partial_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N; i++){\\r\\n for (j=0; j<num_inducing; j++){\\r\\n %s\\r\\n }\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(gradX_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n \\r\\n\\r\\n diag_gradX_func_string = re.sub('Z','X',gradX_func_string,count=0)\\r\\n diag_gradX_func_string = re.sub('int jj','//int jj',diag_gradX_func_string)\\r\\n diag_gradX_func_string = re.sub('j','i',diag_gradX_func_string)\\r\\n diag_gradX_func_string = re.sub('PARTIAL2\\\\(i, i\\\\)','2*PARTIAL1(i)',diag_gradX_func_string)\\r\\n\\r\\n # Code for gradients of Kdiag wrt X\\r\\n self._dKdiag_dX_code= \\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dKdiag_dX_code\\r\\n // Code for computing gradient of diagonal with respect to inputs.\\r\\n int N = partial_array->dimensions[0];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n for (int i=0;i<N; i++){\\r\\n %s\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(diag_gradX_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a\\r\\n # string representation forces recompile when needed Get rid\\r\\n # of Zs in argument for diagonal. TODO: Why wasn't\\r\\n # diag_func_string called here? Need to check that.\\r\\n #self._dKdiag_dX_code = self._dKdiag_dX_code.replace('Z[j', 'X[i')\\r\\n\\r\\n # Code to use when only X is provided. \\r\\n self._dK_dtheta_code_X = self._dK_dtheta_code.replace('Z[', 'X[')\\r\\n self._dK_dX_code_X = self._dK_dX_code.replace('Z[', 'X[').replace('+= PARTIAL2(', '+= 2*PARTIAL2(') \\r\\n self._dK_dtheta_code_X = self._dK_dtheta_code_X.replace('Z2(', 'X2(')\\r\\n self._dK_dX_code_X = self._dK_dX_code_X.replace('Z2(', 'X2(')\\r\\n\\r\\n\\r\\n #TODO: insert multiple functions here via string manipulation\\r\\n #TODO: similar functions for psi_stats\\r\",\n \"def a_function_of_mine():\\n return 'result'\",\n \"def python_function(self):\\n return self._python_function # pylint: disable=protected-access\",\n \"def function(self):\\n return self.devicefuncs[self._funcname]\",\n \"def func(cls):\\n return cls.get_wrapper()(cls.callable)\",\n \"def special_def(self, form):\\n if not len(form) >= 3:\\n raise SyntaxError(\\\"Not enough forms in %s\\\" % form)\\n if not isinstance(form[1], Form):\\n raise SyntaxError(\\\"Expected a list of [funname args...]\\\")\\n\\n doc, code = self._getDocAndCode(form[2:])\\n #print \\\"GOT\\\", code\\n #code.nodes[-1] = ast.Return(code.nodes[-1])\\n args = [x.name for x in form[1][1:]]\\n \\n magicode = self._getMagicCodeForArgs(args)\\n \\n return ast.Function(None, form[1][0].name, args, [], magicode, doc, code)\",\n \"def gen_vee_func(self):\\n dual_func = self.dual_func\\n omt_func = self.omt_func\\n @numba.njit\\n def vee(aval, bval):\\n return dual_func(omt_func(dual_func(aval), dual_func(bval)))\\n return vee\",\n \"def function(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"function\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72852004","0.7195862","0.7117405","0.70892036","0.7076999","0.6858654","0.6826619","0.67727506","0.67657286","0.6740471","0.67363507","0.67158663","0.6688514","0.6664095","0.665405","0.6650802","0.66507447","0.66498697","0.6646827","0.6641116","0.66322","0.6628116","0.6605331","0.6566666","0.65216374","0.65061164","0.6494242","0.6423469","0.6393869","0.6388995","0.6386088","0.636487","0.6363463","0.6362926","0.636123","0.6336199","0.62982345","0.6289591","0.6273761","0.6271196","0.62702817","0.62702817","0.6264745","0.625405","0.6233895","0.62257063","0.6218348","0.6198589","0.6193492","0.61833763","0.6165905","0.61573565","0.61421365","0.61402035","0.61218953","0.61130136","0.6112212","0.6109135","0.61083394","0.6096901","0.6090769","0.60752547","0.607438","0.607179","0.6040324","0.60391784","0.6035885","0.60334736","0.6032388","0.60215616","0.6015523","0.60088277","0.60039526","0.60039526","0.60039526","0.5992931","0.59831357","0.5982573","0.59715974","0.59684855","0.59639835","0.5962034","0.5958344","0.59559083","0.59478813","0.5937469","0.5937469","0.5937469","0.59318143","0.59228337","0.591062","0.59032464","0.5892627","0.58806646","0.58761746","0.5873044","0.5870871","0.5866711","0.5857052","0.58566797","0.5849914"],"string":"[\n \"0.72852004\",\n \"0.7195862\",\n \"0.7117405\",\n \"0.70892036\",\n \"0.7076999\",\n \"0.6858654\",\n \"0.6826619\",\n \"0.67727506\",\n \"0.67657286\",\n \"0.6740471\",\n \"0.67363507\",\n \"0.67158663\",\n \"0.6688514\",\n \"0.6664095\",\n \"0.665405\",\n \"0.6650802\",\n \"0.66507447\",\n \"0.66498697\",\n \"0.6646827\",\n \"0.6641116\",\n \"0.66322\",\n \"0.6628116\",\n \"0.6605331\",\n \"0.6566666\",\n \"0.65216374\",\n \"0.65061164\",\n \"0.6494242\",\n \"0.6423469\",\n \"0.6393869\",\n \"0.6388995\",\n \"0.6386088\",\n \"0.636487\",\n \"0.6363463\",\n \"0.6362926\",\n \"0.636123\",\n \"0.6336199\",\n \"0.62982345\",\n \"0.6289591\",\n \"0.6273761\",\n \"0.6271196\",\n \"0.62702817\",\n \"0.62702817\",\n \"0.6264745\",\n \"0.625405\",\n \"0.6233895\",\n \"0.62257063\",\n \"0.6218348\",\n \"0.6198589\",\n \"0.6193492\",\n \"0.61833763\",\n \"0.6165905\",\n \"0.61573565\",\n \"0.61421365\",\n \"0.61402035\",\n \"0.61218953\",\n \"0.61130136\",\n \"0.6112212\",\n \"0.6109135\",\n \"0.61083394\",\n \"0.6096901\",\n \"0.6090769\",\n \"0.60752547\",\n \"0.607438\",\n \"0.607179\",\n \"0.6040324\",\n \"0.60391784\",\n \"0.6035885\",\n \"0.60334736\",\n \"0.6032388\",\n \"0.60215616\",\n \"0.6015523\",\n \"0.60088277\",\n \"0.60039526\",\n \"0.60039526\",\n \"0.60039526\",\n \"0.5992931\",\n \"0.59831357\",\n \"0.5982573\",\n \"0.59715974\",\n \"0.59684855\",\n \"0.59639835\",\n \"0.5962034\",\n \"0.5958344\",\n \"0.59559083\",\n \"0.59478813\",\n \"0.5937469\",\n \"0.5937469\",\n \"0.5937469\",\n \"0.59318143\",\n \"0.59228337\",\n \"0.591062\",\n \"0.59032464\",\n \"0.5892627\",\n \"0.58806646\",\n \"0.58761746\",\n \"0.5873044\",\n \"0.5870871\",\n \"0.5866711\",\n \"0.5857052\",\n \"0.58566797\",\n \"0.5849914\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":87196,"cells":{"query":{"kind":"string","value":"Compute the indices that are needed (symmertic velocities and space indices)."},"document":{"kind":"string","value":"def set_iload(self):\n k = self.istore[0]\n ksym = self.stencil.get_symmetric()[k]\n v = self.stencil.get_all_velocities()\n\n iload1 = np.zeros(self.istore.shape, dtype=np.int32)\n iload2 = np.zeros(self.istore.shape, dtype=np.int32)\n\n mask = self.distance < 0.5\n iload1[0, mask] = ksym[mask]\n iload2[0, mask] = ksym[mask]\n iload1[1:, mask] = self.istore[1:, mask] + v[k[mask]].T\n iload2[1:, mask] = self.istore[1:, mask] + 2 * v[k[mask]].T\n self.s[mask] = 2.0 * self.distance[mask]\n\n mask = np.logical_not(mask)\n iload1[0, mask] = ksym[mask]\n iload2[0, mask] = k[mask]\n iload1[1:, mask] = self.istore[1:, mask] + v[k[mask]].T\n iload2[1:, mask] = self.istore[1:, mask] + v[k[mask]].T\n self.s[mask] = 0.5 / self.distance[mask]\n\n self.iload.append(iload1)\n self.iload.append(iload2)"},"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 indices_and_currents_TSC_2D( charge_electron, positions_x, positions_y, velocity_x, velocity_y,\\\n x_grid, y_grid, ghost_cells, length_domain_x, length_domain_y, dt ):\n \n \n positions_x_new = positions_x + velocity_x * dt\n positions_y_new = positions_y + velocity_y * dt\n\n base_indices_x = af.data.constant(0, positions_x.elements(), dtype=af.Dtype.u32)\n base_indices_y = af.data.constant(0, positions_x.elements(), dtype=af.Dtype.u32)\n\n dx = af.sum(x_grid[1] - x_grid[0])\n dy = af.sum(y_grid[1] - y_grid[0])\n\n\n # Computing S0_x and S0_y\n ###########################################################################################\n \n # Determining the grid cells containing the respective particles\n \n x_zone = (((af.abs(positions_x - af.sum(x_grid[0])))/dx).as_type(af.Dtype.u32))\n y_zone = (((af.abs(positions_y - af.sum(y_grid[0])))/dy).as_type(af.Dtype.u32))\n\n \n # Determing the indices of the closest grid node in x direction\n\n temp = af.where(af.abs(positions_x-x_grid[x_zone]) < \\\n af.abs(positions_x-x_grid[x_zone + 1])\\\n )\n\n if(temp.elements()>0):\n base_indices_x[temp] = x_zone[temp]\n\n temp = af.where(af.abs(positions_x - x_grid[x_zone]) >= \\\n af.abs(positions_x-x_grid[x_zone + 1])\\\n )\n\n if(temp.elements()>0):\n base_indices_x[temp] = (x_zone[temp] + 1).as_type(af.Dtype.u32) \n\n\n # Determing the indices of the closest grid node in y direction\n\n temp = af.where(af.abs(positions_y-y_grid[y_zone]) < \\\n af.abs(positions_y-y_grid[y_zone + 1])\\\n )\n\n if(temp.elements()>0):\n base_indices_y[temp] = y_zone[temp]\n\n temp = af.where(af.abs(positions_y - y_grid[y_zone])>=af.abs(positions_y-x_grid[y_zone + 1]))\n\n if(temp.elements()>0):\n base_indices_y[temp] = (y_zone[temp] + 1).as_type(af.Dtype.u32) \n\n # Concatenating the index list for near by grid nodes in x direction\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\n\n base_indices_minus_two = (base_indices_x - 2).as_type(af.Dtype.u32) \n base_indices_minus = (base_indices_x - 1).as_type(af.Dtype.u32) \n base_indices_plus = (base_indices_x + 1).as_type(af.Dtype.u32) \n base_indices_plus_two = (base_indices_x + 2).as_type(af.Dtype.u32) \n\n\n\n index_list_x = af.join( 1,\\\n af.join(1, base_indices_minus_two, base_indices_minus, base_indices_x),\\\n af.join(1, base_indices_plus, base_indices_plus_two),\\\n )\n\n\n\n # Concatenating the index list for near by grid nodes in y direction\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\n \n base_indices_minus_two = (base_indices_y - 2).as_type(af.Dtype.u32) \n base_indices_minus = (base_indices_y - 1).as_type(af.Dtype.u32) \n base_indices_plus = (base_indices_y + 1).as_type(af.Dtype.u32) \n base_indices_plus_two = (base_indices_y + 2).as_type(af.Dtype.u32) \n\n\n index_list_y = af.join( 1,\\\n af.join(1, base_indices_minus_two, base_indices_minus, base_indices_y),\\\n af.join(1, base_indices_plus, base_indices_plus_two),\\\n )\n\n # Concatenating the positions_x for determining weights for near by grid nodes in y direction\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\n\n positions_x_5x = af.join( 0,\\\n af.join(0, positions_x, positions_x, positions_x),\\\n af.join(0, positions_x, positions_x),\\\n )\n\n positions_y_5x = af.join( 0,\\\n af.join(0, positions_y, positions_y, positions_y),\\\n af.join(0, positions_y, positions_y),\\\n )\n\n\n\n\n # Determining S0 for positions at t = n * dt\n\n\n distance_nodes_x = x_grid[af.flat(index_list_x)]\n\n distance_nodes_y = y_grid[af.flat(index_list_y)]\n\n\n W_x = 0 * distance_nodes_x.copy()\n W_y = 0 * distance_nodes_y.copy()\n\n\n # Determining weights in x direction\n\n temp = af.where(af.abs(distance_nodes_x - positions_x_5x) < (0.5*dx) )\n\n if(temp.elements()>0):\n W_x[temp] = 0.75 - (af.abs(distance_nodes_x[temp] - positions_x_5x[temp])/dx)**2\n\n temp = af.where((af.abs(distance_nodes_x - positions_x_5x) >= (0.5*dx) )\\\n * (af.abs(distance_nodes_x - positions_x_5x) < (1.5 * dx) )\\\n )\n\n if(temp.elements()>0):\n W_x[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_x[temp] - positions_x_5x[temp])/dx))**2\n\n\n\n # Determining weights in y direction\n\n temp = af.where(af.abs(distance_nodes_y - positions_y_5x) < (0.5*dy) )\n\n if(temp.elements()>0):\n W_y[temp] = 0.75 - (af.abs(distance_nodes_y[temp] - positions_y_5x[temp])/dy)**2\n\n temp = af.where((af.abs(distance_nodes_y - positions_y_5x) >= (0.5*dy) )\\\n * (af.abs(distance_nodes_y - positions_y_5x) < (1.5 * dy) )\\\n )\n\n if(temp.elements()>0):\n W_y[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_y[temp] - positions_y_5x[temp])/dy))**2\n\n # Restructering W_x and W_y for visualization and ease of understanding\n\n W_x = af.data.moddims(W_x, positions_x.elements(), 5)\n W_y = af.data.moddims(W_y, positions_y.elements(), 5)\n\n # Tiling the S0_x and S0_y for the 25 indices around the particle\n \n S0_x = af.tile(W_x, 1, 1, 5)\n S0_y = af.tile(W_y, 1, 1, 5)\n\n\n S0_y = af.reorder(S0_y, 0, 2, 1)\n\n\n\n #Computing S1_x and S1_y\n ###########################################################################################\n\n positions_x_5x_new = af.join( 0,\\\n af.join(0, positions_x_new, positions_x_new, positions_x_new),\\\n af.join(0, positions_x_new, positions_x_new),\\\n )\n\n positions_y_5x_new = af.join( 0,\\\n af.join(0, positions_y_new, positions_y_new, positions_y_new),\\\n af.join(0, positions_y_new, positions_y_new),\\\n )\n\n\n\n\n # Determining S0 for positions at t = n * dt\n\n W_x = 0 * distance_nodes_x.copy()\n W_y = 0 * distance_nodes_y.copy()\n\n\n # Determining weights in x direction\n\n temp = af.where(af.abs(distance_nodes_x - positions_x_5x_new) < (0.5*dx) )\n\n if(temp.elements()>0):\n W_x[temp] = 0.75 - (af.abs(distance_nodes_x[temp] - positions_x_5x_new[temp])/dx)**2\n\n temp = af.where((af.abs(distance_nodes_x - positions_x_5x_new) >= (0.5*dx) )\\\n * (af.abs(distance_nodes_x - positions_x_5x_new) < (1.5 * dx) )\\\n )\n\n if(temp.elements()>0):\n W_x[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_x[temp] \\\n - positions_x_5x_new[temp])/dx\\\n )\\\n )**2\n\n\n\n # Determining weights in y direction\n\n temp = af.where(af.abs(distance_nodes_y - positions_y_5x_new) < (0.5*dy) )\n\n if(temp.elements()>0):\n W_y[temp] = 0.75 - (af.abs(distance_nodes_y[temp] \\\n - positions_y_5x_new[temp]\\\n )/dy\\\n )**2\n\n temp = af.where((af.abs(distance_nodes_y - positions_y_5x_new) >= (0.5*dy) )\\\n * (af.abs(distance_nodes_y - positions_y_5x_new) < (1.5 * dy) )\\\n )\n\n if(temp.elements()>0):\n W_y[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_y[temp] \\\n - positions_y_5x_new[temp])/dy\\\n )\\\n )**2\n\n # Restructering W_x and W_y for visualization and ease of understanding\n\n W_x = af.data.moddims(W_x, positions_x.elements(), 5)\n W_y = af.data.moddims(W_y, positions_x.elements(), 5)\n\n # Tiling the S0_x and S0_y for the 25 indices around the particle \n \n S1_x = af.tile(W_x, 1, 1, 5)\n S1_y = af.tile(W_y, 1, 1, 5)\n\n S1_y = af.reorder(S1_y, 0, 2, 1)\n\n\n ###########################################################################################\n\n # Determining the final weight matrix for currents in 3D matrix form factor\n\n\n W_x = (S1_x - S0_x) * (S0_y + (0.5 *(S1_y - S0_y)) )\n\n\n W_y = (S1_y - S0_y) * (S0_x + (0.5 *(S1_x - S0_x)) )\n\n\n ###########################################################################################\n\n\n # Assigning Jx and Jy according to Esirkepov's scheme\n\n Jx = af.data.constant(0, positions_x.elements(), 5, 5, dtype = af.Dtype.f64)\n Jy = af.data.constant(0, positions_x.elements(), 5, 5, dtype = af.Dtype.f64)\n\n\n Jx[:, 0, :] = -1 * charge_electron * (dx/dt) * W_x[:, 0, :].copy()\n Jx[:, 1, :] = Jx[:, 0, :] + -1 * charge_electron * (dx/dt) * W_x[:, 1, :].copy()\n Jx[:, 2, :] = Jx[:, 1, :] + -1 * charge_electron * (dx/dt) * W_x[:, 2, :].copy()\n Jx[:, 3, :] = Jx[:, 2, :] + -1 * charge_electron * (dx/dt) * W_x[:, 3, :].copy()\n Jx[:, 4, :] = Jx[:, 3, :] + -1 * charge_electron * (dx/dt) * W_x[:, 4, :].copy()\n \n # Computing current density using currents\n \n Jx = (1/(dx * dy)) * Jx\n\n\n Jy[:, :, 0] = -1 * charge_electron * (dy/dt) * W_y[:, :, 0].copy()\n Jy[:, :, 1] = Jy[:, :, 0] + -1 * charge_electron * (dy/dt) * W_y[:, :, 1].copy()\n Jy[:, :, 2] = Jy[:, :, 1] + -1 * charge_electron * (dy/dt) * W_y[:, :, 2].copy()\n Jy[:, :, 3] = Jy[:, :, 2] + -1 * charge_electron * (dy/dt) * W_y[:, :, 3].copy()\n Jy[:, :, 4] = Jy[:, :, 3] + -1 * charge_electron * (dy/dt) * W_y[:, :, 4].copy()\n \n # Computing current density using currents\n\n Jy = (1/(dx * dy)) * Jy\n\n # Preparing the final index and current vectors\n ###########################################################################################\n \n \n # Determining the x indices for charge deposition\n index_list_x_Jx = af.flat(af.tile(index_list_x, 1, 1, 5))\n\n # Determining the y indices for charge deposition\n y_current_zone = af.tile(index_list_y, 1, 1, 5)\n index_list_y_Jx = af.flat(af.reorder(y_current_zone, 0, 2, 1))\n\n\n currents_Jx = af.flat(Jx)\n\n # Determining the x indices for charge deposition\n index_list_x_Jy = af.flat(af.tile(index_list_x, 1, 1, 5))\n\n # Determining the y indices for charge deposition\n y_current_zone = af.tile(index_list_y, 1, 1, 5)\n index_list_y_Jy = af.flat(af.reorder(y_current_zone, 0, 2, 1))\n \n # Flattenning the Currents array\n currents_Jy = af.flat(Jy)\n\n af.eval(index_list_x_Jx, index_list_y_Jx)\n af.eval(index_list_x_Jy, index_list_y_Jy)\n af.eval(currents_Jx, currents_Jy)\n\n\n return index_list_x_Jx, index_list_y_Jx, currents_Jx,\\\n index_list_x_Jy, index_list_y_Jy, currents_Jy","def generate_index(self):\n begin_o, end_o, begin_a, end_a = 0, 0, 0, 0\n for obs_space, act_space in zip(self.env.observation_space, self.env.action_space):\n end_o = end_o + obs_space.shape[0]\n if isinstance(act_space, Box):\n end_a = act_space.shape[0]\n else:\n end_a = act_space.n\n range_o = (begin_o, end_o)\n range_a = (begin_a, end_a)\n self.observation_index.append(range_o)\n self.action_index.append(range_a)\n begin_o = end_o\n begin_a = end_a","def mesh_span_indices(self):\n self._ensure_mesh()\n k2m = self._knots_to_mesh\n return np.where(k2m[1:] != k2m[:-1])[0]","def get_index(self, x, y):\n i = (y - self.y0) // self.dy\n j = (x - self.x0) // self.dx\n i = min(max(i, 0), self.n-1)\n j = min(max(j, 0), self.m-1)\n return [i, j]","def calculate_esi_index(radius, mass, temperature):\n density = Calculator.calculate_average_density(radius, mass)\n escape_velocity = Calculator.calculate_escape_velocity(radius, mass)\n\n factors = [\n (radius, 6.3781e6, 0.57/4),\n (density, 5513, 1.07/4),\n (escape_velocity, 11200, 0.70/4),\n (temperature, 288, 5.58/4)\n ]\n res = [(1 - abs(x - y)/abs(x + y)) ** z for x, y, z in factors]\n return functools.reduce(operator.mul, res)","def mainIndices(self):\n return self.i1, self.i2","def get_indices(self):\r\n return self._indices","def indices(self) -> np.ndarray:\n return self.impl.indices","def __build_state_index(self):\n\n # the index for the system state\n # [rho_i, q_in, q_out, r_i, f_i]\n x_index = {}\n\n # add the density index\n x_index['density'] = OrderedDict()\n for i in range(0, self.num_cells):\n x_index['density'][i] = i\n dim_state = self.num_cells\n\n # add the upstream boundary flow\n x_index['qin'] = dim_state\n x_index['qout'] = dim_state + 1\n dim_state += 2\n\n # add on ramp variables\n # x_index['onramp'] = OrderedDict()\n # if self.cell_onramp is not None:\n # # if onramp exist in the network, otherwise skip\n # for cell_id in self.cell_onramp:\n # # add the absolute index into the state index dictionary\n # # r_i index = self.x_index{'onramp'][cell_i]\n # x_index['onramp'][cell_id] = dim_state\n # dim_state += 1\n #\n #\n # # add off ramp state variables\n # x_index['offramp'] = OrderedDict()\n # if self.cell_offramp is not None:\n # for cell_id in self.cell_offramp:\n # # add the absolute index\n # x_index['offramp'][cell_id] = dim_state\n # dim_state += 1\n\n return x_index, dim_state","def indices(self):\n _indices = []\n for h in self.miller.indices():\n _indices.append(self.indices_hkl(*h)[0])\n return _indices","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 get_index(self):\n return (np.sqrt(self.dielectric))","def create_elastic_indices():\n # initial values\n alpha, alpha2, sigma = 10, 10, 50\n shape = (96, 288) # same as shape of input images\n x_mesh, y_mesh = np.meshgrid(np.arange(shape[1]), np.arange(shape[0]))\n\n # below is used once per epoch for the elastic deformation\n g_1d = signal.gaussian(300, sigma)\n kernel_deform = np.outer(g_1d, g_1d)\n dx = signal.fftconvolve(np.random.rand(*shape) * 2 - 1, kernel_deform, mode='same')\n dy = signal.fftconvolve(np.random.rand(*shape) * 2 - 1, kernel_deform, mode='same')\n dx = alpha * (dx - np.mean(dx)) / np.std(dx)\n dy = alpha2 * (dy - np.mean(dy)) / np.std(dy)\n indices_x, indices_y = x_mesh + dx, y_mesh + dy\n indices_x_clipped = np.clip(indices_x, a_min=0, a_max=shape[1] - 1)\n indices_y_clipped = np.clip(indices_y, a_min=0, a_max=shape[0] - 1)\n return indices_x_clipped, indices_y_clipped","def get_idx(velocity, coord):\n d = velocity.node_intervals\n dx=d[0]\n dz=d[1]\n dy=d[2]\n mn = velocity.min_coords\n mnx=mn[0]\n mnz=mn[1]\n mny=mn[2]\n ix = int((coord[0] - mnx)/dx)\n iz = int((coord[1] - mnz)/dz)\n iy = int((coord[2] - mny)/dy)\n return (ix, iz, iy)","def _get_k_indices(self, ks):\n if self.staticneighs:\n idx_ks = ks\n else:\n idx_ks = [self.ks.index(e) for e in ks]\n return idx_ks","def indices(self):\n return self.index.indices","def get_analytical_velocities(self):\n # create empty numpy array for accelerations\n velocities = np.zeros((3, len(self.times)))\n # tangential velocity is angular velocity multiplied by radius but radius is one\n vt = self.wz\n # decompose tangential velocity in x and y components\n velocities[0, :] = vt * -sin(self.th[:, 2])\n velocities[1, :] = vt * cos(self.th[:, 2])\n # linear velocity along z axis\n velocities[2, :] = self.v0x + self.ax * self.times\n return velocities","def getIndices(self):\r\n return self._indices","def Indexes(self, latitudes, longitudes):\n res = self._transform.TransformPoints(\n np.column_stack((longitudes, latitudes)))\n res = list(zip(*res))\n x, y = np.array(res[0]), np.array(res[1])\n idx_col = self._inv_txf[0] + self._inv_txf[1] * x + self._inv_txf[2] * y\n idx_row = self._inv_txf[3] + self._inv_txf[4] * x + self._inv_txf[5] * y\n return idx_row.astype(int), idx_col.astype(int)","def indices(self):\n i, j, _edge = self.indicesAndEdge()\n return i, j","def update_idx(self):\n self.idx = (self.F * self.FMUL +\n self.E * self.EMUL +\n self.Z * self.ZMUL +\n self.A * self.AMUL +\n self.B * self.BMUL )","def vir_indices(self):\n indices = []\n for index,item in enumerate(self):\n if item==0:\n indices.append(index)\n return indices","def master_ndindex(self): # itermaster_indices(self):\n return itertools_product(\n *[range(*r) for r in self.location]\n ) # TODO check","def coord_indices_of(self, v_list):\n return [self.coord_index_of(v) for v in v_list]","def efficient_integer_vectors(self):\n return self._efficient_integer_vectors","def test_get_indices_several_existing_items(self):\r\n control_ids = ['PC.354', 'PC.355', 'PC.356', 'PC.481', 'PC.593']\r\n exp_control_indices = [0, 1, 2, 3, 4]\r\n\r\n fast_ids = ['PC.607', 'PC.634', 'PC.635', 'PC.636']\r\n exp_fast_indices = [5, 6, 7, 8]\r\n\r\n obs_control = _get_indices(self.dist_matrix_header, control_ids)\r\n self.assertEqual(obs_control, exp_control_indices)\r\n\r\n obs_fast = _get_indices(self.dist_matrix_header, fast_ids)\r\n self.assertEqual(obs_fast, exp_fast_indices)","def _state_index(state):\n delta_y, delta_x, bird_lmh, pipe_lmh, is_flapping = state\n actions, height, width, _, _, _ = Q.shape\n\n y = int((height / 2) + (delta_y / step_r) - 1)\n x = int((width / 2) + (delta_x / step_c) - 1)\n\n return y, x, bird_lmh, pipe_lmh, is_flapping","def get_analytically_computed_optimization_parameter_indices(self):\n indices = []\n if '/offsetParameterIndices' in self.f:\n indices.extend(self.f['/offsetParameterIndices'])\n\n if '/scalingParameterIndices' in self.f:\n indices.extend(self.f['/scalingParameterIndices'])\n\n if '/sigmaParameterIndices' in self.f:\n indices.extend(self.f['/sigmaParameterIndices'])\n\n return list(set(indices))","def calc_target_index(self, state, cx, cy):\n # Calc front axle position\n fx = state.x + self.L * np.cos(state.yaw) / 2.0\n fy = state.y + self.L * np.sin(state.yaw) / 2.0\n\n # Search nearest point index\n dx = []\n dy = []\n\n i = 0\n for icx in cx:\n if i < self.ind - 1000:\n dx.append(float(\"inf\"))\n else:\n dx.append(fx - icx)\n i += 1\n\n i = 0\n for icy in cy:\n if i < self.ind - 1000:\n dy.append(float(\"inf\"))\n else:\n dy.append(fy - icy)\n i += 1\n\n # dx = [fx - icx for icx in cx]\n # dy = [fy - icy for icy in cy]\n\n d = np.hypot(dx, dy)\n target_idx = np.argmin(d)\n\n # Project RMS error onto front axle vector\n front_axle_vec = [-np.cos(state.yaw + np.pi / 2), -\n np.sin(state.yaw + np.pi / 2)]\n\n error_front_axle = np.dot(\n [dx[target_idx], dy[target_idx]], front_axle_vec)\n\n\n\n return target_idx, error_front_axle","def calculate_index_and_derivative(wl):\n index = np.sqrt(1 + (0.6961663 * wl * wl) / (wl * wl - 0.0684043 * 0.0684043)\n + (0.4079426 * wl * wl) / (wl * wl - 0.1162414 * 0.1162414)\n + (0.8974794 * wl * wl) / (wl * wl - 9.896161 * 9.896161)\n )\n\n index_derivative = \\\n (\n - (1.79496 * wl * wl * wl) / (pow(-97.934 + wl * wl, 2))\n + (1.79496 * wl) / (-97.934 + wl * wl)\n\n - (0.815885 * wl * wl * wl) / (pow(-0.0135121 + wl * wl, 2))\n + (0.815885 * wl) / (-0.0135121 + wl * wl)\n\n - (1.39233 * wl * wl * wl) / (pow(-0.00467915 + wl * wl, 2))\n + (1.39233 * wl) / (-0.00467915 + wl * wl)\n ) \\\n / \\\n (2 * np.sqrt(\n 1\n + (0.897479 * wl * wl) / (-97.934 + wl * wl)\n + (0.407943 * wl * wl) / (-0.0135121 + wl * wl)\n + (0.696166 * wl * wl) / (-0.00467915 + wl * wl)\n )\n )\n return index, index_derivative","def indices(self):\n return range(len(self))","def get_local_indices(self, part, ctx):\n return self.map_to_global(\n F.arange(0, self.local_size(part), ctx=ctx), part\n )","def damping_index(self):\n start_index = self.kp_index[1]\n end_index = start_index + self.control_dim\n\n if self.impedance_flag:\n return (start_index, end_index)\n else:\n return None","def comp_amplification_index(self):\n \n self.grid_tuning_in=self.inputs.grid_tuning_in\n self.grid_tuning_out=gl.comp_grid_tuning_index(self.L,self.nx,(self.r[0:self.n_e**2,:]).T) \n self.grid_tuning_out_inhib=gl.comp_grid_tuning_index(self.L,self.nx,(self.r[self.n_e**2:,:]).T)\n\n self.grid_amp_index=self.grid_tuning_out/self.grid_tuning_in","def compute_tides(self):\r\n # take the period of the asteroid rotation\r\n P = self.period\r\n\r\n # compute the angle of the asteroid\r\n phase = 2*np.pi*(float(self.t) % P)/P\r\n\r\n # get points\r\n points = self.V.tabulate_dof_coordinates()[::3]\r\n\r\n # rotate points to the position they should be in, in the solar frame\r\n points = self.rotate_points(points, -phase)\r\n\r\n # get the acceleration, multiplies by rho\r\n force = float(self.rho)*self.tidal_acc(points)\r\n\r\n # rotate the force back to the actual points\r\n force = self.rotate_points(force, phase)\r\n\r\n # update the force function from the array\r\n self.ftides.vector()[:] = force.flatten()","def get_vacancy_indices(array):\t\n\tvacancy_indices = np.argwhere(array == 0)\n\treturn vacancy_indices","def _get_indexes(self, participants):\n tr_idx = int(np.floor(self.tr_size*len(participants)))\n j = self.val_size + self.tr_size\n val_idx = int(np.floor(j*len(participants)))\n return tr_idx, val_idx","def indices(self):\n return self._kbounded_partitions","def build_amg_index_sets(L_sizes):\n neqns = L_sizes[0][0]\n velocityDOF=[]\n for start in range(1,3):\n velocityDOF.append(np.arange(start=start,\n stop=1+neqns,\n step=3,\n dtype='i'))\n velocityDOF_full=np.vstack(velocityDOF).transpose().flatten()\n velocity_u_DOF = []\n velocity_u_DOF.append(np.arange(start=0,\n stop=2*neqns//3,\n step=2,\n dtype='i'))\n velocity_u_DOF_full = np.vstack(velocity_u_DOF).transpose().flatten()\n velocity_v_DOF = []\n velocity_v_DOF.append(np.arange(start=1,\n stop=1+2*neqns//3,\n step=2,\n dtype='i'))\n velocity_v_DOF_full = np.vstack(velocity_v_DOF).transpose().flatten()\n isvelocity = PETSc.IS()\n isvelocity.createGeneral(velocityDOF_full)\n isu = PETSc.IS()\n isu.createGeneral(velocity_u_DOF_full)\n isv = PETSc.IS()\n isv.createGeneral(velocity_v_DOF_full)\n return [isvelocity, isu, isv]","def two_dim_index(self, k):\n ind_x = k % self.nx\n ind_y = (k - ind_x) / self.nx\n return (int(ind_y), int(ind_x))","def csm_indices(csm):\r\n return csm_properties(csm)[1]","def getGlobalIdxVals( self, i : int ):\n return range(self._layout.starts[i],self._layout.ends[i])","def get_param_indexes(self):\n self.debug.start_function('get_param_indexes')\n\n for i, key in enumerate(self.mcmc_version.param_keys):\n self.param_idxs[key] = i\n for i, key in enumerate(self.mcmc_version.interp_keys):\n self.interp_idxs[key] = i\n\n self.debug.end_function()","def vector(self,\n i: int,\n j: int) -> np.ndarray:\n return self[j].coord - self[i].coord","def jw_number_indices(n_electrons, n_qubits):\n occupations = itertools.combinations(range(n_qubits), n_electrons)\n indices = [sum([2**n for n in occupation]) for occupation in occupations]\n return indices","def _compute_indices(self):\n self.indices = np.arange(len(self.im_filenames))\n np.random.shuffle(self.indices)","def computeIndices(org_center:tuple, rot_center:tuple, xyPairs, angle, org_box_offset:tuple):\n rot_center = np.array([[rot_center[0]], [rot_center[1]]])\n org_center = np.array([[org_center[0]], [org_center[1]]])\n org_box_offset = np.array([[org_box_offset[0]], [org_box_offset[1]]])\n newPairs = xyPairs - rot_center\n\n rotMatrix = buildRotationMatrix(angle)\n\n orgPairs = np.matmul(rotMatrix, newPairs)\n\n return np.array(orgPairs) + org_center + org_box_offset","def indices(self, position=None):\n \n raise NotImplementedError()","def ets(self):\n r = (self.table[0, 0] + self.table[0, 1]) * (self.table[0, 0] + self.table[1, 0]) / self.N\n return (self.table[0, 0] - r) / (self.table[0, 0] + self.table[0, 1] + self.table[1, 0] - r)","def _get_permutated_segments_indices(\n self, randomized: bool, random_state: Optional[np.random.mtrand.RandomState]\n ) -> np.ndarray:\n idx = np.arange(self.dy.size)\n\n if randomized:\n if random_state is None:\n random_state = np.random.RandomState()\n idx = random_state.permutation(idx)\n return idx","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 indices ( self, x1, y1, z1, x2, y2, z2 ):\n xi1, yi1, zi1 = self.index(min(x1, x2), min(y1, y2), min(z1, z2))\n xi2, yi2, zi2 = self.index(max(x1, x2), max(y1, y2), max(z1, z2))\n return s_[xi1:xi2+1], s_[yi1:yi2+1], s_[zi1:zi2+1]","def surface_indices(self):\n return self._unique_surface_indices(self.surf_mesh)","def getVectors(self):\n vectors = dict()\n i = 0\n N = len(self.db.invertedIndex)\n for w, (idf, docs) in self.db.invertedIndex.items():\n for doc, tf in docs.items():\n try:\n vectors[doc][i] = tf * idf\n except KeyError as k:\n vectors[doc] = {i: tf * idf}\n i += 1\n i = 0;\n return vectors","def get_indices_input_target(num_obs, input_len, step_size, forecast_horizon, target_len):\n input_len = round(input_len) # just a precaution\n start_position = 0\n stop_position = num_obs - 1\n\n inpseq_first_idx = start_position\n inpseq_last_idx = inpseq_first_idx + input_len\n target_first_idx = inpseq_last_idx + forecast_horizon\n target_last_idx = target_first_idx + target_len\n print(\"target_last_idx = {}\".format(target_last_idx))\n print(\"stop_position = {}\".format(stop_position))\n indices = []\n while target_last_idx <= stop_position:\n indices.append((inpseq_first_idx, inpseq_last_idx, target_first_idx, target_last_idx))\n inpseq_first_idx += step_size\n inpseq_last_idx += step_size\n target_first_idx += inpseq_last_idx + forecast_horizon\n target_last_idx += target_first_idx + target_len\n return indices","def hoggar_indices():\n return list(product([0,1], repeat=6))","def getIndices(self, tokens):\n tokenTxt, posTxt = attachTokens(tokens)\n if tokenTxt in self.tokenIndices:\n tokenIdx = self.tokenIndices[tokenTxt]\n else:\n tokenIdx = self.tokenIndices[unk]\n if posTxt in self.posIndices:\n posIdx = self.posIndices[posTxt]\n else:\n posIdx = self.posIndices[unk]\n return tokenIdx, posIdx","def mesh_support_idx(self, j):\n self._ensure_mesh()\n supp = self.support_idx(j)\n return (self._knots_to_mesh[supp[0]], self._knots_to_mesh[supp[1]])","def _get_index(self):\n\n return self.index\n\n # to avoid having differences bigger than 2pi","def _iter_indices(self, frame, y):\n pass","def indices(self):\n return tuple([slice(*r) for r in self.location])","def _get_block_indices(y):\n block_labels, block_inv, block_sizes = np.unique(\n y, return_inverse=True, return_counts=True\n )\n\n n_blocks = len(block_labels)\n block_inds = range(n_blocks)\n\n block_vert_inds = []\n for i in block_inds:\n # get the inds from the original graph\n inds = np.where(block_inv == i)[0]\n block_vert_inds.append(inds)\n return block_vert_inds, block_inds, block_inv","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 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 index_to_obs(a,b, grid_x, grid_y):\n position = grid_x[a]\n velocity = grid_y[b]\n return position, velocity","def compute_positions(self):\n return (self.x + DIRECTIONS[self.facing_direction][0]) % (self.image.shape[0] - 1), \\\n (self.y + DIRECTIONS[self.facing_direction][1]) % (self.image.shape[1] - 1)","def morton_idx(pts):\n lib = _initlib()\n p = require(pts, dtype=float64, requirements=['C']) \n inv_cell_width = 1.0/8192\n npts = len(p)\n out = empty(npts, dtype=int64)\n lib.get_morton_idx(p, npts, inv_cell_width, out)\n return out","def _extract_t_indices(self, X, X2=None, dL_dK=None):\r\n\r\n # TODO: some fast checking here to see if this needs recomputing?\r\n self._t = X[:, 0]\r\n if not X.shape[1] == 2:\r\n raise ValueError('Input matrix for ode1 covariance should have two columns, one containing times, the other output indices')\r\n self._index = np.asarray(X[:, 1],dtype=np.int)\r\n # Sort indices so that outputs are in blocks for computational\r\n # convenience.\r\n self._order = self._index.argsort()\r\n self._index = self._index[self._order]\r\n self._t = self._t[self._order]\r\n self._rorder = self._order.argsort() # rorder is for reversing the order\r\n \r\n if X2 is None:\r\n self._t2 = None\r\n self._index2 = None\r\n self._order2 = self._order\r\n self._rorder2 = self._rorder\r\n else:\r\n if not X2.shape[1] == 2:\r\n raise ValueError('Input matrix for ode1 covariance should have two columns, one containing times, the other output indices')\r\n self._t2 = X2[:, 0]\r\n self._index2 = np.asarray(X2[:, 1],dtype=np.int)\r\n self._order2 = self._index2.argsort()\r\n self._index2 = self._index2[self._order2]\r\n self._t2 = self._t2[self._order2]\r\n self._rorder2 = self._order2.argsort() # rorder2 is for reversing order\r\n\r\n if dL_dK is not None:\r\n self._dL_dK = dL_dK[self._order, :]\r\n self._dL_dK = self._dL_dK[:, self._order2]","def getstate(self):\r\n return [self.tied_indices,\r\n self.fixed_indices,\r\n self.fixed_values,\r\n self.constrained_indices,\r\n self.constraints]","def get_img_indices():\n if K.image_dim_ordering() == 'th':\n return 0, 1, 2, 3\n else:\n return 0, 3, 1, 2","def _fixed_indicies(self):\n fixed_inds = self.constraints == 'fixed'\n return fixed_inds","def create_vectors(self):\n self.localStatistics = []\n self.lastStatistics = []\n self.globalV = []\n self.estimate = []\n self.delta = []\n self.drift = []\n self.slack = [] # only for coordBased model","def test_y_vector_init(self):\n # If you change the y-vector ordering, change here too #Y_VECTOR_CHANGESITE\n\n eng_fields = np.zeros(EngineeringState.N_ENGINEERING_FIELDS)\n component_array = eng_fields[EngineeringState._COMPONENT_START_INDEX:EngineeringState._COMPONENT_END_INDEX]\n for comp_i in range(0, N_COMPONENTS):\n component_array[comp_i + N_COMPONENTS * 0] = True # connected\n component_array[comp_i + N_COMPONENTS * 1] = 1 + (0.01 * comp_i) # capacity\n component_array[comp_i + N_COMPONENTS * 2] = 222200 + comp_i # temperature\n component_array[comp_i + N_COMPONENTS * 3] = comp_i % 2 # coolant_hab_one\n component_array[comp_i + N_COMPONENTS * 4] = True # coolant_hab_two\n component_array[comp_i + N_COMPONENTS * 5] = False # coolant_ayse\n\n coolant_array = eng_fields[EngineeringState._COOLANT_START_INDEX:EngineeringState._COOLANT_END_INDEX]\n for cool_i in range(0, N_COOLANT_LOOPS):\n coolant_array[cool_i + N_COOLANT_LOOPS * 0] = 555500 + cool_i # coolant_temp\n coolant_array[cool_i + N_COOLANT_LOOPS * 1] = cool_i % 2 # primary_pump_on\n coolant_array[cool_i + N_COOLANT_LOOPS * 2] = True # secondary_pump_on\n\n rad_array = eng_fields[EngineeringState._RADIATOR_START_INDEX:EngineeringState._RADIATOR_END_INDEX]\n for rad_i in range(0, N_RADIATORS):\n rad_array[rad_i + N_RADIATORS * 0] = rad_i % 4 # attached_to_coolant_loop\n rad_array[rad_i + N_RADIATORS * 1] = rad_i % 2 # functioning\n\n y0 = np.concatenate((np.array([\n 0x111, 0x222, # x\n 0x333, 0x444, # y\n 0x555, 0x777, # vx\n 0x888, 0x999, # vy\n 0.01, 0.02, # heading\n 0.03, 0.04, # spin\n 0xEEE, 0xFFF, # fuel\n 5, 6, # throttle\n 1, -1, # only First is landed on Second\n 0, 1, # Second is broken\n common.SRB_EMPTY,\n 1 # time_acc\n ]),\n eng_fields\n ))\n\n ps = PhysicsState(y0, self.proto_state)\n self.assertTrue(np.array_equal(ps.y0(), y0.astype(ps.y0().dtype)))\n self.assertEqual(ps['First'].landed_on, 'Second')\n\n proto_state = ps.as_proto()\n proto_state.timestamp = 50\n self.assertEqual(proto_state.entities[0].x, 0x111)\n self.assertEqual(proto_state.entities[0].y, 0x333)\n self.assertEqual(proto_state.entities[1].x, 0x222)\n self.assertEqual(proto_state.entities[1].y, 0x444)\n self.assertEqual(proto_state.entities[0].vx, 0x555)\n self.assertEqual(proto_state.entities[0].vy, 0x888)\n self.assertEqual(proto_state.entities[1].vx, 0x777)\n self.assertEqual(proto_state.entities[1].vy, 0x999)\n self.assertEqual(proto_state.entities[0].heading, 0.01)\n self.assertEqual(proto_state.entities[1].heading, 0.02)\n self.assertEqual(proto_state.entities[0].spin, 0.03)\n self.assertEqual(proto_state.entities[1].spin, 0.04)\n self.assertEqual(proto_state.entities[0].fuel, 0xEEE)\n self.assertEqual(proto_state.entities[1].fuel, 0xFFF)\n self.assertEqual(proto_state.entities[0].landed_on, 'Second')\n self.assertEqual(proto_state.entities[1].landed_on, '')\n self.assertEqual(proto_state.timestamp, 50)\n self.assertTrue(proto_state.entities[1].broken)\n\n for i, component in enumerate(ps.engineering.components):\n self.assertEqual(component.connected, True, msg=i)\n self.assertEqual(component.capacity, 1 + (0.01 * i), msg=i)\n self.assertEqual(component.temperature, 222200 + i, msg=i)\n self.assertEqual(component.coolant_hab_one, bool(i % 2), msg=i)\n self.assertEqual(component.coolant_hab_two, True, msg=i)\n self.assertEqual(component.coolant_ayse, False, msg=i)\n\n for i, coolant in enumerate(ps.engineering.coolant_loops):\n self.assertEqual(coolant.coolant_temp, 555500 + i, msg=i)\n self.assertEqual(coolant.primary_pump_on, bool(i % 2), msg=i)\n self.assertEqual(coolant.secondary_pump_on, True, msg=i)\n\n for i, radiator in enumerate(ps.engineering.radiators):\n pass\n self.assertEqual(radiator.attached_to_coolant_loop, i % 4, msg=i)\n self.assertEqual(radiator.functioning, bool(i % 2), msg=i)","def _get_block_indices(y: np.ndarray) -> Tuple[List[np.ndarray], range, np.ndarray]:\n block_labels: np.ndarray\n block_inv: np.ndarray\n block_sizes: np.ndarray\n block_labels, block_inv, block_sizes = np.unique(\n y, return_inverse=True, return_counts=True\n )\n\n n_blocks = len(block_labels)\n block_inds = range(n_blocks)\n\n block_vert_inds = []\n for i in block_inds:\n # get the inds from the original graph\n inds = np.where(block_inv == i)[0]\n block_vert_inds.append(inds)\n return block_vert_inds, block_inds, block_inv","def expandcal(self):\n ind=np.zeros(self.spec.shape[0]).astype(int)\n for k in range(self.nscan):\n ind[self.getscanind(k)]=k\n ind[self.getcalind(k)]=k\n return ind","def velocities(self, return_np=False):\n if return_np:\n return self.si_values()[3:]\n return [self.v_x, self.v_y, self.v_z]","def min_indices(self):\n return {term.minterm_index for term in self.iter_minterms()}","def indices(self, _user=None):\n return [p.index for p in self.get_active_smallvariant_cases()]","def box_collision_info(self):\r\n position = np.zeros((self.Npart,3)) # antall part, dim, iterasjoner\r\n position[:,:] = np.random.uniform(0,1e-6, size = (self.Npart,3))\r\n velocity = np.zeros((self.Npart,3))\r\n velocity[:,:] = np.random.normal(0,self.sigma,size = (self.Npart,3))\r\n\r\n part_collided = 0\r\n part_escaped = 0\r\n momentum = 0\r\n\r\n print 'engine started'\r\n for i in xrange(1,self.n):\r\n #collision\r\n position += velocity*dt\r\n l_hole = position[:,0:2] > self.L/4\r\n h_hole = position[:,0:2] < (3*self.L)/4\r\n pos_xy = np.logical_and(l_hole, h_hole)\r\n pos_xy = np.logical_and(pos_xy[:,0], pos_xy[:,1])\r\n pos_z = position[:,2] < 0\r\n esc_part = np.logical_and(pos_z, pos_xy)\r\n\r\n #velocity[esc_part] = velocity[esc_part]\r\n part_escaped += np.sum(esc_part)\r\n\r\n for j in xrange(0,3):\r\n impact_wall_pos = np.logical_and(position[:,j] > 0,\r\n position[:,j] < self.L)\r\n velocity[np.logical_not(impact_wall_pos),j] = -velocity[\r\n np.logical_not(impact_wall_pos),j]\r\n\r\n\r\n if j == 0:\r\n part_collided += np.sum(np.logical_not(impact_wall_pos),j)\r\n momentum += np.sum(2*self.m*abs(velocity[np.logical_not(\r\n impact_wall_pos),j]))\r\n\r\n\r\n\r\n position[position < 0] = 0\r\n position[position >self.L] = self.L\r\n\r\n particle_collided = part_collided/2\r\n return position, velocity,part_escaped, impact_wall_pos, particle_collided, momentum","def get_indexes(self):\n indexes = []\n for c in self.components:\n indexes.extend(c.get_indexes())\n return indexes","def vector(molec, dihed, nonH, energy):\n #Torison\n if dihed:\n pass\n #XYZ\n else:\n coords = ()\n if nonH:\n for atom in molec.atoms:\n coords += atom.coords\n else:\n for atom in molec.atoms:\n if atom.atomicnum > 1:\n coords += atom.coords\n #Energy\n if energy:\n coords += (molec.energy/10.0,)\n return coords","def get_final_pruned_indices(self):\n return self.final_pruned_indices","def calculate_useful_stuff(self):\n\n self.pos = self.pair[1].position - self.pair[0].position\n self.vel = self.pair[1].velocity - self.pair[0].velocity\n\n self.r = self.pos.length()\n self.v = self.vel.length()\n self.inv_r = 1.0 / self.r\n\n self.rvec = self.pos * self.inv_r\n self.rdot = (self.rvec * self.vel).sum() * self.rvec\n self.rdot_mag = self.rdot.length()\n\n self.vth = self.vel - self.rdot\n self.vth_mag = self.vth.length()\n self.vth_vec = self.vth / self.vth_mag","def velocity_field(self):\n return scipy.dstack((self._u_int, self._v_int))","def get_segment_index(datadb):\n #match in time!!!!\n if cfg.use_saliency:\n segment_index_tar = util.get_time_for_visual(datadb)\n segment_index_tar_future = OrderedDict()\n for key in segment_index_tar.keys():\n segment_index_tar_future[key] = np.array(segment_index_tar[key])+max_encoder_seq_length\n return segment_index_tar,segment_index_tar_future","def get_ecc(self):\n mu_mass = G*(self._mm + self._sm)\n h_mom = self.sp_ang_mom()\n vel = self.getvel_xyz()\n pos = self.getpos_xyz()\n e_vec = 1.0/mu_mass*(np.cross(vel, h_mom) -\n mu_mass*pos/np.linalg.norm(pos))\n return e_vec","def calc_index(self, x, y, model, variable, weights=None, time_weighting=True):\n\n if weights is None:\n # set weights according to cell area\n if x.cell_area is not None:\n weights = x._get_weighting_matrix()\n else:\n print('WARNING: no weights when calculating performance index')\n weights = np.ones(x.data.shape)\n else: # weights are given\n if x.cell_area is not None:\n print('WARNING: cell weights are given, while cell_area available from data!!')\n\n from pycmbs.diagnostic import Diagnostic\n D = Diagnostic(x, y=y)\n # reichler performance index\n # (might return a list if multiple times analyzed)\n e2 = D.calc_reichler_index(weights) # returns [time, index]\n if e2 is not None:\n e2 = np.ma.masked_where(np.isnan(e2), e2)\n\n # Note that the returned value is E**2 for each timestep!\n # When doing the normalization, one needs to take the sqrt(E++2)\n # to obtain the actual RMSE\n if e2 is None:\n return None\n else:\n if time_weighting:\n days = np.asarray(x._days_per_month()) # number of days for each month\n wt = days / float(days.sum()) # weights for time\n else:\n wt = np.ones(len(e2)) / float(len(e2))\n\n return np.sqrt((e2 * wt).sum())","def get_uncut_indices(atoms, orig, vec1, offset=None):\n\n if isinstance(orig, int):\n orig = atoms.get_positions()[orig]\n else:\n orig = np.array(orig)\n if isinstance(vec1, int):\n vec1 = atoms.get_positions()[vec1]\n else:\n vec1 = np.array(vec1)\n\n# if vec2 and isinstance(vec2, int):\n# vec2 = atoms.get_positions()[vec2]\n# elif vec2:\n# vec2 = np.array(vec2)\n# if vec3 and isinstance(vec3, int):\n# vec3 = atoms.get_positions()[vec3]\n# elif vec3:\n# vec3 = np.array(vec3)\n#\n# if vec2:\n# plane_vec = np.cross(vec1-orig, vec2-orig)\n# else:\n# plane_vec = vec1-orig\n#\n# nplane_vec = plane_vec/np.linalg.norm(plane_vec)\n#\n# if vec2 and vec3 and nplane_vec.dot(vec3-orig) < 0:\n# nplane_vec *= -1\n\n plane_vec = vec1 - orig\n nplane_vec = plane_vec/np.linalg.norm(plane_vec)\n\n if offset:\n orig += offset*nplane_vec\n\n atom_indices = [i for i,a in enumerate(atoms) if (a.position - orig).dot(nplane_vec) > 0]\n return atom_indices","def _index(self, i, j):\n assert self._isvalid(i), 'i term (%s) is out of bounds' % i\n assert self._isvalid(j), 'j term (%s) is out of bounds' % j\n\n return self.n * (i - 1) + (j - 1)","def compute_idx(pos, edge_index):\n\n pos_i = pos[edge_index[0]]\n pos_j = pos[edge_index[1]]\n\n d_ij = torch.norm(abs(pos_j - pos_i), dim=-1, keepdim=False).unsqueeze(-1) + 1e-5\n v_ji = (pos_i - pos_j) / d_ij\n\n unique, counts = torch.unique(\n edge_index[0], sorted=True, return_counts=True\n ) # Get central values\n full_index = (\n torch.arange(0, edge_index[0].size()[0]).cuda().int()\n ) # init full index\n\n # Compute 1\n repeat = torch.repeat_interleave(counts, counts)\n counts_repeat1 = torch.repeat_interleave(full_index, repeat) # 0,...,0,1,...,1,...\n\n # Compute 2\n split = torch.split(full_index, counts.tolist()) # split full index\n index2 = list(edge_index[0].data.cpu().numpy()) # get repeat index\n counts_repeat2 = torch.cat(itemgetter(*index2)(split), dim=0) # 0,1,2,...,0,1,2,..\n\n # Compute angle embeddings\n v1 = v_ji[counts_repeat1.long()]\n v2 = v_ji[counts_repeat2.long()]\n\n angle = (v1 * v2).sum(-1).unsqueeze(-1)\n angle = torch.clamp(angle, min=-1.0, max=1.0) + 1e-6 + 1.0\n\n return counts_repeat1.long(), counts_repeat2.long(), angle","def _getitem2d(self, index):\n\n lovects = self._getlovects()\n hivects = self._gethivects()\n fields = self._getfields()\n\n ix = index[0]\n iz = index[1]\n\n if len(fields[0].shape) > self.dim:\n ncomps = fields[0].shape[-1]\n else:\n ncomps = 1\n\n if len(index) > self.dim:\n if ncomps > 1:\n ic = index[2]\n else:\n raise Exception('Too many indices given')\n else:\n ic = None\n\n nx = hivects[0,:].max() - self.nghosts\n nz = hivects[1,:].max() - self.nghosts\n\n if npes > 1:\n nx = comm_world.allreduce(nx, op=mpi.MAX)\n nz = comm_world.allreduce(nz, op=mpi.MAX)\n\n if isinstance(ix, slice):\n ixstart = max(ix.start or -self.nghosts, -self.nghosts)\n ixstop = min(ix.stop or nx + 1 + self.nghosts, nx + self.overlaps[0] + self.nghosts)\n else:\n ixstart = ix\n ixstop = ix + 1\n if isinstance(iz, slice):\n izstart = max(iz.start or -self.nghosts, -self.nghosts)\n izstop = min(iz.stop or nz + 1 + self.nghosts, nz + self.overlaps[1] + self.nghosts)\n else:\n izstart = iz\n izstop = iz + 1\n\n # --- Setup the size of the array to be returned and create it.\n # --- Space is added for multiple components if needed.\n sss = (max(0, ixstop - ixstart),\n max(0, izstop - izstart))\n if ncomps > 1 and ic is None:\n sss = tuple(list(sss) + [ncomps])\n resultglobal = np.zeros(sss, dtype=_libwarpx._numpy_real_dtype)\n\n datalist = []\n for i in range(len(fields)):\n\n # --- The ix1, 2 etc are relative to global indexing\n ix1 = max(ixstart, lovects[0,i])\n ix2 = min(ixstop, lovects[0,i] + fields[i].shape[0])\n iz1 = max(izstart, lovects[1,i])\n iz2 = min(izstop, lovects[1,i] + fields[i].shape[1])\n\n if ix1 < ix2 and iz1 < iz2:\n\n sss = (slice(ix1 - lovects[0,i], ix2 - lovects[0,i]),\n slice(iz1 - lovects[1,i], iz2 - lovects[1,i]))\n if ic is not None:\n sss = tuple(list(sss) + [ic])\n\n vslice = (slice(ix1 - ixstart, ix2 - ixstart),\n slice(iz1 - izstart, iz2 - izstart))\n\n datalist.append((vslice, fields[i][sss]))\n\n if npes == 1:\n all_datalist = [datalist]\n else:\n all_datalist = comm_world.allgather(datalist)\n\n for datalist in all_datalist:\n for vslice, ff in datalist:\n resultglobal[vslice] = ff\n\n # --- Now remove any of the reduced dimensions.\n sss = [slice(None), slice(None)]\n if not isinstance(ix, slice):\n sss[0] = 0\n if not isinstance(iz, slice):\n sss[1] = 0\n\n return resultglobal[tuple(sss)]","def agent_locs_idx(self):\n return tuple(self.agent_locs.T)","def _position_and_velocity(self, jd):\n pos, vel = terra(self.latitude.radians, self.longitude.radians,\n self.elevation.au, jd.gast)\n pos = einsum('ij...,j...->i...', jd.MT, pos)\n vel = einsum('ij...,j...->i...', jd.MT, vel)\n return pos, vel","def indices_hkl(self, H, K, L):\n from cctbx import miller\n _symm_equiv = miller.sym_equiv_indices(self.sg, (H, K, L))\n _indices = sorted([i.h() for i in _symm_equiv.indices()],\n reverse=True)\n if len(_indices) < _symm_equiv.multiplicity(False):\n _indices = _indices + [(-hh, -kk, -ll)\n for (hh, kk, ll) in _indices]\n return _indices","def get_analytical_accelerations(self):\n # create empty numpy array for accelerations\n accelerations = np.zeros((3, len(self.times)))\n # radial accelerations is equal to angular velocity^2 / radius but radius is unitary is this trajectory\n radial_acceleration = self.wz ** 2\n # decompose radial accelerations in x and y components\n accelerations[0, :] = radial_acceleration * -cos(self.th[:, 2])\n accelerations[1, :] = radial_acceleration * -sin(self.th[:, 2])\n # accelerations along x axis is constant\n accelerations[2, :] = self.ax\n return accelerations","def _get_valid_indices(\n self,\n _signals: np.ndarray,\n _labels: np.ndarray,\n window_start_indices: np.ndarray = None,\n elm_start_indices: np.ndarray = None,\n elm_stop_indices: np.ndarray = None,\n valid_t0: np.ndarray = None,\n labels: np.ndarray = None,\n signals: np.ndarray = None,\n ) -> Tuple[\n np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray\n ]:\n # allowed indices; time data points which can be used for creating the data chunks\n _valid_t0 = np.ones(_labels.shape, dtype=np.int32)\n _valid_t0[\n -(config.signal_window_size + config.label_look_ahead) + 1 :\n ] = 0\n\n # indices for active elm events in each elm event\n active_elm_events = np.nonzero(_labels >= 0.5)[0]\n\n if signals is None:\n # initialize arrays\n window_start_indices = np.array([0])\n elm_start_indices = active_elm_events[0]\n elm_stop_indices = active_elm_events[-1]\n valid_t0 = _valid_t0\n signals = _signals\n labels = _labels\n else:\n # concat on axis 0 (time dimension)\n last_index = len(labels) - 1\n window_start_indices = np.append(\n window_start_indices, last_index + 1\n )\n elm_start_indices = np.append(\n elm_start_indices, active_elm_events[0] + last_index + 1\n )\n elm_stop_indices = np.append(\n elm_stop_indices, active_elm_events[-1] + last_index + 1\n )\n valid_t0 = np.concatenate([valid_t0, _valid_t0])\n signals = np.concatenate([signals, _signals], axis=0)\n labels = np.concatenate([labels, _labels], axis=0)\n\n return (\n signals,\n labels,\n valid_t0,\n window_start_indices,\n elm_start_indices,\n elm_stop_indices,\n )","def cal_globalIndexH(self):\n h_local = self.cal_localIndexH()\n h_global = np.sum(h_local)\n\n return h_global","def indices(self):\n if self._indices is None:\n i = []\n\n # TODO: this is not right for multi-column keys\n # TODO: new style indexes\n\n global_name = '^DD(%s,0,\"IX\",\"0\")' % self.fileid\n prefix = '^DD(%s,0,\"IX\",' % self.fileid\n while 1:\n global_name = M.mexec('set s0=$query(%s)' % global_name, M.INOUT(\"\"))[0]\n if not global_name or not global_name.startswith(prefix):\n break\n suffix = global_name[len(prefix):-1]\n parts = suffix.split(\",\")\n idx_name = parts[0][1:-1]\n idx_table = parts[1]\n idx_columns = parts[2:]\n index = Index(idx_name, idx_table, idx_columns)\n i.append(index)\n\n # A second list, gives indices for a field\n columns = {}\n for idx in i:\n for c in idx.columns:\n columns[c] = 1\n\n # Now trawl the listed columns in the data dictionary, and load their\n # cross references.\n cr_names = {}\n for c in columns.keys():\n idx_root = M.Globals[\"^DD\"][self.fileid][c][1]\n if not idx_root[0].exists():\n continue\n for cr_id, val in idx_root.keys_with_decendants():\n if float(cr_id) > 0:\n cr_header = idx_root[cr_id][0].value\n parts = cr_header.split(\"^\")\n if len(parts) == 2 and parts[1]: # if more than 2 parts, assume MUMPs trigger\n f = cr_names.get(parts[1], list())\n f.append(c)\n cr_names[parts[1]] = f\n\n # Now, just delete items from the index list if they are not in cr_names\n self._indices = []\n for index in i:\n cr = cr_names.get(index.name)\n if cr:\n # verify columns - lots of errors in real systems\n if len(cr) == len(index.columns):\n invalid = False\n for c in cr:\n if c not in index.columns:\n invalid = True\n continue\n if not invalid:\n self._indices.append(index)\n\n return self._indices","def calcAllIntensities(self, xc, yc):\n\n tp = 0.0\n ix = 0\n iy = 0\n h = 0\n ints = np.zeros([5, 5])\n ints_inner = np.zeros([5, 5])\n # ints = [[0.0] * 5] * 5\n # ints_inner = [[0.0] * 5] * 5\n x = 0.0\n y = 0.0\n xc1 = 0.0\n yc1 = 0.0\n xc1 = xc\n yc1 = yc\n \n for h in np.arange(1,5,1):\n for k in np.arange(1,5,1):\n ints[h][k] = 0.0\n ints_inner[h][k] = 0.0\n\n for k in np.arange(0, 2, 1):\n for h in np.arange(0, 2, 1):\n for ix in np.arange(0, self.stepp + 1, 1):\n for iy in np.arange(0, self.stepp + 1, 1):\n #print(k, h, ix, iy)\n if self.qc_format == 0 :\n x = -(1 + self.G) + h * (1 + 2 * self.G) + (ix * (1.0 / self.stepp))\n y = -(1 + self.G) + k * (1 + 2 * self.G) + (iy * (1.0 / self.stepp))\n if self.spot_radius == 0 or math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)) == 0 :\n tp = 0.0\n else :\n tp = (math.sin((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))) / ((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))\n tp = math.pow(tp,2)\n #print(tp)\n elif self.qc_format == 1 :\n x = -1 + h + (ix * (1 / self.stepp))\n y = -1 + k + (iy * (1 / self.stepp))\n ints[h + 1][k + 1] += math.pow(math.exp((math.pow((x - xc1),2) + math.pow((y - yc1),2) ) / math.pow(self.spot_radius,2)), -1)\n if (self.spot_radius * self.spot_radius) == 0 or ((x - xc1) * (y - yc1) * np.pi * np.pi) == 0 :\n tp = 0.0\n else :\n tp = (math.sin((x - xc1) * np.pi / self.spot_radius) * math.sin((y - yc1) * np.pi / self.spot_radius)) / (((x - xc1) * (y - yc1) * np.pi * np.pi) / (self.spot_radius * self.spot_radius))\n\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.radius_inner,2):\n ints_inner[h + 1][k + 1] += tp\n else :\n if self.qc_format == 1 :\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.cell_qc, 2):\n ints[h + 1][k + 1] += tp\n if (math.pow(x,2) + math.pow(y,2)) <= 1 :\n #print(math.pow(x,2) + math.pow(y,2))\n ints[h + 1][k + 1] += tp\n # print(ints[h + 1][k + 1])\t\t\t\t\t\t\n tp = 0.0\n\n # print(ints)\n\n Aq = 0.0\n Bq = 0.0\n Cq = 0.0\n Dq = 0.0\n Ac_inner = 0.0\n Bc_inner = 0.0\n Cc_inner = 0.0\n Dc_inner = 0.0\n Ac = 0.0\n Bc = 0.0\n Cc = 0.0\n Dc = 0.0\n Ac = ints[1][2]\n Bc = ints[2][2]\n Cc = ints[2][1]\n Dc = ints[1][1]\n\n Ac_inner = ints_inner[1][2]\n Bc_inner = ints_inner[2][2]\n Cc_inner = ints_inner[2][1]\n Dc_inner = ints_inner[1][1]\n Ac *= self.QE\n Bc *= self.QE\n Cc *= self.QE\n Dc *= self.QE\n\n Ac_inner *= self.QE_inner\n Bc_inner *= self.QE_inner\n Cc_inner *= self.QE_inner\n Dc_inner *= self.QE_inner\n Ac += Ac_inner\n Bc += Bc_inner\n Cc += Cc_inner\n Dc += Dc_inner\n\n Aq = Ac\n Bq = Bc\n Cq = Cc\n Dq = Dc\n\n #tp/TP = cotribution percentage of the spot with respect to max (spot center)\n if self.smooth == 0 :\n if (Config.hplk_c0_e * self.TP) == 0 :\n cnst = 0\n else :\n cnst = ((Parameters.TPS / (self.n_ml * self.n_ml)) * self.lamb) / (Config.hplk_c0_e * self.TP) #Número de fótons efeticos\n if Config.flag_spice == 1 :\n Ac *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP) #W\n Bc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\n Cc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\n Dc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\n Ac *= 1 / (math.pow(self.cell_qc * 1e-6,2)) #W/(m^2)\n Bc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\n Cc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\n Dc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\n #Ac *= 1 / (self.lamb * 1e6); #Adequação da irradiância para a unidade W/m2micm conforme necessário no SPICE\n #Bc *= 1 / (self.lamb * 1e6);\n #Cc *= 1 / (self.lamb * 1e6);\n #Dc *= 1 / (self.lamb * 1e6);\n \n ############################## DOUBLE CHECK ##############################\n # self.grava_arquivos = 1\n # self.flag_V_QC = 0\n # grava_le_arquivos(0) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n # self.flag_V_QC = 1\n # self.grava_arquivos = 0\n ############################## DOUBLE CHECK ##############################\n Aq *= cnst * 1e9\n Bq *= cnst * 1e9\n Cq *= cnst * 1e9\n Dq *= cnst * 1e9\n else :\n Aq *= cnst * 1e9\n Bq *= cnst * 1e9\n Cq *= cnst * 1e9\n Dq *= cnst * 1e9\n\n # 'returns' all the intensities\n self.A_intensity = Aq\n self.B_intensity = Bq\n self.C_intensity = Cq\n self.D_intensity = Dq","def atom_idxs(self):\n\n return np.array([atom.atom_idxs for atom in self])","def crearIndices(self):\n l = self.encontrarCaracteres()\n i=0\n for c in l:\n self.indices[c] = i\n i+=1"],"string":"[\n \"def indices_and_currents_TSC_2D( charge_electron, positions_x, positions_y, velocity_x, velocity_y,\\\\\\n x_grid, y_grid, ghost_cells, length_domain_x, length_domain_y, dt ):\\n \\n \\n positions_x_new = positions_x + velocity_x * dt\\n positions_y_new = positions_y + velocity_y * dt\\n\\n base_indices_x = af.data.constant(0, positions_x.elements(), dtype=af.Dtype.u32)\\n base_indices_y = af.data.constant(0, positions_x.elements(), dtype=af.Dtype.u32)\\n\\n dx = af.sum(x_grid[1] - x_grid[0])\\n dy = af.sum(y_grid[1] - y_grid[0])\\n\\n\\n # Computing S0_x and S0_y\\n ###########################################################################################\\n \\n # Determining the grid cells containing the respective particles\\n \\n x_zone = (((af.abs(positions_x - af.sum(x_grid[0])))/dx).as_type(af.Dtype.u32))\\n y_zone = (((af.abs(positions_y - af.sum(y_grid[0])))/dy).as_type(af.Dtype.u32))\\n\\n \\n # Determing the indices of the closest grid node in x direction\\n\\n temp = af.where(af.abs(positions_x-x_grid[x_zone]) < \\\\\\n af.abs(positions_x-x_grid[x_zone + 1])\\\\\\n )\\n\\n if(temp.elements()>0):\\n base_indices_x[temp] = x_zone[temp]\\n\\n temp = af.where(af.abs(positions_x - x_grid[x_zone]) >= \\\\\\n af.abs(positions_x-x_grid[x_zone + 1])\\\\\\n )\\n\\n if(temp.elements()>0):\\n base_indices_x[temp] = (x_zone[temp] + 1).as_type(af.Dtype.u32) \\n\\n\\n # Determing the indices of the closest grid node in y direction\\n\\n temp = af.where(af.abs(positions_y-y_grid[y_zone]) < \\\\\\n af.abs(positions_y-y_grid[y_zone + 1])\\\\\\n )\\n\\n if(temp.elements()>0):\\n base_indices_y[temp] = y_zone[temp]\\n\\n temp = af.where(af.abs(positions_y - y_grid[y_zone])>=af.abs(positions_y-x_grid[y_zone + 1]))\\n\\n if(temp.elements()>0):\\n base_indices_y[temp] = (y_zone[temp] + 1).as_type(af.Dtype.u32) \\n\\n # Concatenating the index list for near by grid nodes in x direction\\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\\n\\n base_indices_minus_two = (base_indices_x - 2).as_type(af.Dtype.u32) \\n base_indices_minus = (base_indices_x - 1).as_type(af.Dtype.u32) \\n base_indices_plus = (base_indices_x + 1).as_type(af.Dtype.u32) \\n base_indices_plus_two = (base_indices_x + 2).as_type(af.Dtype.u32) \\n\\n\\n\\n index_list_x = af.join( 1,\\\\\\n af.join(1, base_indices_minus_two, base_indices_minus, base_indices_x),\\\\\\n af.join(1, base_indices_plus, base_indices_plus_two),\\\\\\n )\\n\\n\\n\\n # Concatenating the index list for near by grid nodes in y direction\\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\\n \\n base_indices_minus_two = (base_indices_y - 2).as_type(af.Dtype.u32) \\n base_indices_minus = (base_indices_y - 1).as_type(af.Dtype.u32) \\n base_indices_plus = (base_indices_y + 1).as_type(af.Dtype.u32) \\n base_indices_plus_two = (base_indices_y + 2).as_type(af.Dtype.u32) \\n\\n\\n index_list_y = af.join( 1,\\\\\\n af.join(1, base_indices_minus_two, base_indices_minus, base_indices_y),\\\\\\n af.join(1, base_indices_plus, base_indices_plus_two),\\\\\\n )\\n\\n # Concatenating the positions_x for determining weights for near by grid nodes in y direction\\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\\n\\n positions_x_5x = af.join( 0,\\\\\\n af.join(0, positions_x, positions_x, positions_x),\\\\\\n af.join(0, positions_x, positions_x),\\\\\\n )\\n\\n positions_y_5x = af.join( 0,\\\\\\n af.join(0, positions_y, positions_y, positions_y),\\\\\\n af.join(0, positions_y, positions_y),\\\\\\n )\\n\\n\\n\\n\\n # Determining S0 for positions at t = n * dt\\n\\n\\n distance_nodes_x = x_grid[af.flat(index_list_x)]\\n\\n distance_nodes_y = y_grid[af.flat(index_list_y)]\\n\\n\\n W_x = 0 * distance_nodes_x.copy()\\n W_y = 0 * distance_nodes_y.copy()\\n\\n\\n # Determining weights in x direction\\n\\n temp = af.where(af.abs(distance_nodes_x - positions_x_5x) < (0.5*dx) )\\n\\n if(temp.elements()>0):\\n W_x[temp] = 0.75 - (af.abs(distance_nodes_x[temp] - positions_x_5x[temp])/dx)**2\\n\\n temp = af.where((af.abs(distance_nodes_x - positions_x_5x) >= (0.5*dx) )\\\\\\n * (af.abs(distance_nodes_x - positions_x_5x) < (1.5 * dx) )\\\\\\n )\\n\\n if(temp.elements()>0):\\n W_x[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_x[temp] - positions_x_5x[temp])/dx))**2\\n\\n\\n\\n # Determining weights in y direction\\n\\n temp = af.where(af.abs(distance_nodes_y - positions_y_5x) < (0.5*dy) )\\n\\n if(temp.elements()>0):\\n W_y[temp] = 0.75 - (af.abs(distance_nodes_y[temp] - positions_y_5x[temp])/dy)**2\\n\\n temp = af.where((af.abs(distance_nodes_y - positions_y_5x) >= (0.5*dy) )\\\\\\n * (af.abs(distance_nodes_y - positions_y_5x) < (1.5 * dy) )\\\\\\n )\\n\\n if(temp.elements()>0):\\n W_y[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_y[temp] - positions_y_5x[temp])/dy))**2\\n\\n # Restructering W_x and W_y for visualization and ease of understanding\\n\\n W_x = af.data.moddims(W_x, positions_x.elements(), 5)\\n W_y = af.data.moddims(W_y, positions_y.elements(), 5)\\n\\n # Tiling the S0_x and S0_y for the 25 indices around the particle\\n \\n S0_x = af.tile(W_x, 1, 1, 5)\\n S0_y = af.tile(W_y, 1, 1, 5)\\n\\n\\n S0_y = af.reorder(S0_y, 0, 2, 1)\\n\\n\\n\\n #Computing S1_x and S1_y\\n ###########################################################################################\\n\\n positions_x_5x_new = af.join( 0,\\\\\\n af.join(0, positions_x_new, positions_x_new, positions_x_new),\\\\\\n af.join(0, positions_x_new, positions_x_new),\\\\\\n )\\n\\n positions_y_5x_new = af.join( 0,\\\\\\n af.join(0, positions_y_new, positions_y_new, positions_y_new),\\\\\\n af.join(0, positions_y_new, positions_y_new),\\\\\\n )\\n\\n\\n\\n\\n # Determining S0 for positions at t = n * dt\\n\\n W_x = 0 * distance_nodes_x.copy()\\n W_y = 0 * distance_nodes_y.copy()\\n\\n\\n # Determining weights in x direction\\n\\n temp = af.where(af.abs(distance_nodes_x - positions_x_5x_new) < (0.5*dx) )\\n\\n if(temp.elements()>0):\\n W_x[temp] = 0.75 - (af.abs(distance_nodes_x[temp] - positions_x_5x_new[temp])/dx)**2\\n\\n temp = af.where((af.abs(distance_nodes_x - positions_x_5x_new) >= (0.5*dx) )\\\\\\n * (af.abs(distance_nodes_x - positions_x_5x_new) < (1.5 * dx) )\\\\\\n )\\n\\n if(temp.elements()>0):\\n W_x[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_x[temp] \\\\\\n - positions_x_5x_new[temp])/dx\\\\\\n )\\\\\\n )**2\\n\\n\\n\\n # Determining weights in y direction\\n\\n temp = af.where(af.abs(distance_nodes_y - positions_y_5x_new) < (0.5*dy) )\\n\\n if(temp.elements()>0):\\n W_y[temp] = 0.75 - (af.abs(distance_nodes_y[temp] \\\\\\n - positions_y_5x_new[temp]\\\\\\n )/dy\\\\\\n )**2\\n\\n temp = af.where((af.abs(distance_nodes_y - positions_y_5x_new) >= (0.5*dy) )\\\\\\n * (af.abs(distance_nodes_y - positions_y_5x_new) < (1.5 * dy) )\\\\\\n )\\n\\n if(temp.elements()>0):\\n W_y[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_y[temp] \\\\\\n - positions_y_5x_new[temp])/dy\\\\\\n )\\\\\\n )**2\\n\\n # Restructering W_x and W_y for visualization and ease of understanding\\n\\n W_x = af.data.moddims(W_x, positions_x.elements(), 5)\\n W_y = af.data.moddims(W_y, positions_x.elements(), 5)\\n\\n # Tiling the S0_x and S0_y for the 25 indices around the particle \\n \\n S1_x = af.tile(W_x, 1, 1, 5)\\n S1_y = af.tile(W_y, 1, 1, 5)\\n\\n S1_y = af.reorder(S1_y, 0, 2, 1)\\n\\n\\n ###########################################################################################\\n\\n # Determining the final weight matrix for currents in 3D matrix form factor\\n\\n\\n W_x = (S1_x - S0_x) * (S0_y + (0.5 *(S1_y - S0_y)) )\\n\\n\\n W_y = (S1_y - S0_y) * (S0_x + (0.5 *(S1_x - S0_x)) )\\n\\n\\n ###########################################################################################\\n\\n\\n # Assigning Jx and Jy according to Esirkepov's scheme\\n\\n Jx = af.data.constant(0, positions_x.elements(), 5, 5, dtype = af.Dtype.f64)\\n Jy = af.data.constant(0, positions_x.elements(), 5, 5, dtype = af.Dtype.f64)\\n\\n\\n Jx[:, 0, :] = -1 * charge_electron * (dx/dt) * W_x[:, 0, :].copy()\\n Jx[:, 1, :] = Jx[:, 0, :] + -1 * charge_electron * (dx/dt) * W_x[:, 1, :].copy()\\n Jx[:, 2, :] = Jx[:, 1, :] + -1 * charge_electron * (dx/dt) * W_x[:, 2, :].copy()\\n Jx[:, 3, :] = Jx[:, 2, :] + -1 * charge_electron * (dx/dt) * W_x[:, 3, :].copy()\\n Jx[:, 4, :] = Jx[:, 3, :] + -1 * charge_electron * (dx/dt) * W_x[:, 4, :].copy()\\n \\n # Computing current density using currents\\n \\n Jx = (1/(dx * dy)) * Jx\\n\\n\\n Jy[:, :, 0] = -1 * charge_electron * (dy/dt) * W_y[:, :, 0].copy()\\n Jy[:, :, 1] = Jy[:, :, 0] + -1 * charge_electron * (dy/dt) * W_y[:, :, 1].copy()\\n Jy[:, :, 2] = Jy[:, :, 1] + -1 * charge_electron * (dy/dt) * W_y[:, :, 2].copy()\\n Jy[:, :, 3] = Jy[:, :, 2] + -1 * charge_electron * (dy/dt) * W_y[:, :, 3].copy()\\n Jy[:, :, 4] = Jy[:, :, 3] + -1 * charge_electron * (dy/dt) * W_y[:, :, 4].copy()\\n \\n # Computing current density using currents\\n\\n Jy = (1/(dx * dy)) * Jy\\n\\n # Preparing the final index and current vectors\\n ###########################################################################################\\n \\n \\n # Determining the x indices for charge deposition\\n index_list_x_Jx = af.flat(af.tile(index_list_x, 1, 1, 5))\\n\\n # Determining the y indices for charge deposition\\n y_current_zone = af.tile(index_list_y, 1, 1, 5)\\n index_list_y_Jx = af.flat(af.reorder(y_current_zone, 0, 2, 1))\\n\\n\\n currents_Jx = af.flat(Jx)\\n\\n # Determining the x indices for charge deposition\\n index_list_x_Jy = af.flat(af.tile(index_list_x, 1, 1, 5))\\n\\n # Determining the y indices for charge deposition\\n y_current_zone = af.tile(index_list_y, 1, 1, 5)\\n index_list_y_Jy = af.flat(af.reorder(y_current_zone, 0, 2, 1))\\n \\n # Flattenning the Currents array\\n currents_Jy = af.flat(Jy)\\n\\n af.eval(index_list_x_Jx, index_list_y_Jx)\\n af.eval(index_list_x_Jy, index_list_y_Jy)\\n af.eval(currents_Jx, currents_Jy)\\n\\n\\n return index_list_x_Jx, index_list_y_Jx, currents_Jx,\\\\\\n index_list_x_Jy, index_list_y_Jy, currents_Jy\",\n \"def generate_index(self):\\n begin_o, end_o, begin_a, end_a = 0, 0, 0, 0\\n for obs_space, act_space in zip(self.env.observation_space, self.env.action_space):\\n end_o = end_o + obs_space.shape[0]\\n if isinstance(act_space, Box):\\n end_a = act_space.shape[0]\\n else:\\n end_a = act_space.n\\n range_o = (begin_o, end_o)\\n range_a = (begin_a, end_a)\\n self.observation_index.append(range_o)\\n self.action_index.append(range_a)\\n begin_o = end_o\\n begin_a = end_a\",\n \"def mesh_span_indices(self):\\n self._ensure_mesh()\\n k2m = self._knots_to_mesh\\n return np.where(k2m[1:] != k2m[:-1])[0]\",\n \"def get_index(self, x, y):\\n i = (y - self.y0) // self.dy\\n j = (x - self.x0) // self.dx\\n i = min(max(i, 0), self.n-1)\\n j = min(max(j, 0), self.m-1)\\n return [i, j]\",\n \"def calculate_esi_index(radius, mass, temperature):\\n density = Calculator.calculate_average_density(radius, mass)\\n escape_velocity = Calculator.calculate_escape_velocity(radius, mass)\\n\\n factors = [\\n (radius, 6.3781e6, 0.57/4),\\n (density, 5513, 1.07/4),\\n (escape_velocity, 11200, 0.70/4),\\n (temperature, 288, 5.58/4)\\n ]\\n res = [(1 - abs(x - y)/abs(x + y)) ** z for x, y, z in factors]\\n return functools.reduce(operator.mul, res)\",\n \"def mainIndices(self):\\n return self.i1, self.i2\",\n \"def get_indices(self):\\r\\n return self._indices\",\n \"def indices(self) -> np.ndarray:\\n return self.impl.indices\",\n \"def __build_state_index(self):\\n\\n # the index for the system state\\n # [rho_i, q_in, q_out, r_i, f_i]\\n x_index = {}\\n\\n # add the density index\\n x_index['density'] = OrderedDict()\\n for i in range(0, self.num_cells):\\n x_index['density'][i] = i\\n dim_state = self.num_cells\\n\\n # add the upstream boundary flow\\n x_index['qin'] = dim_state\\n x_index['qout'] = dim_state + 1\\n dim_state += 2\\n\\n # add on ramp variables\\n # x_index['onramp'] = OrderedDict()\\n # if self.cell_onramp is not None:\\n # # if onramp exist in the network, otherwise skip\\n # for cell_id in self.cell_onramp:\\n # # add the absolute index into the state index dictionary\\n # # r_i index = self.x_index{'onramp'][cell_i]\\n # x_index['onramp'][cell_id] = dim_state\\n # dim_state += 1\\n #\\n #\\n # # add off ramp state variables\\n # x_index['offramp'] = OrderedDict()\\n # if self.cell_offramp is not None:\\n # for cell_id in self.cell_offramp:\\n # # add the absolute index\\n # x_index['offramp'][cell_id] = dim_state\\n # dim_state += 1\\n\\n return x_index, dim_state\",\n \"def indices(self):\\n _indices = []\\n for h in self.miller.indices():\\n _indices.append(self.indices_hkl(*h)[0])\\n return _indices\",\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 get_index(self):\\n return (np.sqrt(self.dielectric))\",\n \"def create_elastic_indices():\\n # initial values\\n alpha, alpha2, sigma = 10, 10, 50\\n shape = (96, 288) # same as shape of input images\\n x_mesh, y_mesh = np.meshgrid(np.arange(shape[1]), np.arange(shape[0]))\\n\\n # below is used once per epoch for the elastic deformation\\n g_1d = signal.gaussian(300, sigma)\\n kernel_deform = np.outer(g_1d, g_1d)\\n dx = signal.fftconvolve(np.random.rand(*shape) * 2 - 1, kernel_deform, mode='same')\\n dy = signal.fftconvolve(np.random.rand(*shape) * 2 - 1, kernel_deform, mode='same')\\n dx = alpha * (dx - np.mean(dx)) / np.std(dx)\\n dy = alpha2 * (dy - np.mean(dy)) / np.std(dy)\\n indices_x, indices_y = x_mesh + dx, y_mesh + dy\\n indices_x_clipped = np.clip(indices_x, a_min=0, a_max=shape[1] - 1)\\n indices_y_clipped = np.clip(indices_y, a_min=0, a_max=shape[0] - 1)\\n return indices_x_clipped, indices_y_clipped\",\n \"def get_idx(velocity, coord):\\n d = velocity.node_intervals\\n dx=d[0]\\n dz=d[1]\\n dy=d[2]\\n mn = velocity.min_coords\\n mnx=mn[0]\\n mnz=mn[1]\\n mny=mn[2]\\n ix = int((coord[0] - mnx)/dx)\\n iz = int((coord[1] - mnz)/dz)\\n iy = int((coord[2] - mny)/dy)\\n return (ix, iz, iy)\",\n \"def _get_k_indices(self, ks):\\n if self.staticneighs:\\n idx_ks = ks\\n else:\\n idx_ks = [self.ks.index(e) for e in ks]\\n return idx_ks\",\n \"def indices(self):\\n return self.index.indices\",\n \"def get_analytical_velocities(self):\\n # create empty numpy array for accelerations\\n velocities = np.zeros((3, len(self.times)))\\n # tangential velocity is angular velocity multiplied by radius but radius is one\\n vt = self.wz\\n # decompose tangential velocity in x and y components\\n velocities[0, :] = vt * -sin(self.th[:, 2])\\n velocities[1, :] = vt * cos(self.th[:, 2])\\n # linear velocity along z axis\\n velocities[2, :] = self.v0x + self.ax * self.times\\n return velocities\",\n \"def getIndices(self):\\r\\n return self._indices\",\n \"def Indexes(self, latitudes, longitudes):\\n res = self._transform.TransformPoints(\\n np.column_stack((longitudes, latitudes)))\\n res = list(zip(*res))\\n x, y = np.array(res[0]), np.array(res[1])\\n idx_col = self._inv_txf[0] + self._inv_txf[1] * x + self._inv_txf[2] * y\\n idx_row = self._inv_txf[3] + self._inv_txf[4] * x + self._inv_txf[5] * y\\n return idx_row.astype(int), idx_col.astype(int)\",\n \"def indices(self):\\n i, j, _edge = self.indicesAndEdge()\\n return i, j\",\n \"def update_idx(self):\\n self.idx = (self.F * self.FMUL +\\n self.E * self.EMUL +\\n self.Z * self.ZMUL +\\n self.A * self.AMUL +\\n self.B * self.BMUL )\",\n \"def vir_indices(self):\\n indices = []\\n for index,item in enumerate(self):\\n if item==0:\\n indices.append(index)\\n return indices\",\n \"def master_ndindex(self): # itermaster_indices(self):\\n return itertools_product(\\n *[range(*r) for r in self.location]\\n ) # TODO check\",\n \"def coord_indices_of(self, v_list):\\n return [self.coord_index_of(v) for v in v_list]\",\n \"def efficient_integer_vectors(self):\\n return self._efficient_integer_vectors\",\n \"def test_get_indices_several_existing_items(self):\\r\\n control_ids = ['PC.354', 'PC.355', 'PC.356', 'PC.481', 'PC.593']\\r\\n exp_control_indices = [0, 1, 2, 3, 4]\\r\\n\\r\\n fast_ids = ['PC.607', 'PC.634', 'PC.635', 'PC.636']\\r\\n exp_fast_indices = [5, 6, 7, 8]\\r\\n\\r\\n obs_control = _get_indices(self.dist_matrix_header, control_ids)\\r\\n self.assertEqual(obs_control, exp_control_indices)\\r\\n\\r\\n obs_fast = _get_indices(self.dist_matrix_header, fast_ids)\\r\\n self.assertEqual(obs_fast, exp_fast_indices)\",\n \"def _state_index(state):\\n delta_y, delta_x, bird_lmh, pipe_lmh, is_flapping = state\\n actions, height, width, _, _, _ = Q.shape\\n\\n y = int((height / 2) + (delta_y / step_r) - 1)\\n x = int((width / 2) + (delta_x / step_c) - 1)\\n\\n return y, x, bird_lmh, pipe_lmh, is_flapping\",\n \"def get_analytically_computed_optimization_parameter_indices(self):\\n indices = []\\n if '/offsetParameterIndices' in self.f:\\n indices.extend(self.f['/offsetParameterIndices'])\\n\\n if '/scalingParameterIndices' in self.f:\\n indices.extend(self.f['/scalingParameterIndices'])\\n\\n if '/sigmaParameterIndices' in self.f:\\n indices.extend(self.f['/sigmaParameterIndices'])\\n\\n return list(set(indices))\",\n \"def calc_target_index(self, state, cx, cy):\\n # Calc front axle position\\n fx = state.x + self.L * np.cos(state.yaw) / 2.0\\n fy = state.y + self.L * np.sin(state.yaw) / 2.0\\n\\n # Search nearest point index\\n dx = []\\n dy = []\\n\\n i = 0\\n for icx in cx:\\n if i < self.ind - 1000:\\n dx.append(float(\\\"inf\\\"))\\n else:\\n dx.append(fx - icx)\\n i += 1\\n\\n i = 0\\n for icy in cy:\\n if i < self.ind - 1000:\\n dy.append(float(\\\"inf\\\"))\\n else:\\n dy.append(fy - icy)\\n i += 1\\n\\n # dx = [fx - icx for icx in cx]\\n # dy = [fy - icy for icy in cy]\\n\\n d = np.hypot(dx, dy)\\n target_idx = np.argmin(d)\\n\\n # Project RMS error onto front axle vector\\n front_axle_vec = [-np.cos(state.yaw + np.pi / 2), -\\n np.sin(state.yaw + np.pi / 2)]\\n\\n error_front_axle = np.dot(\\n [dx[target_idx], dy[target_idx]], front_axle_vec)\\n\\n\\n\\n return target_idx, error_front_axle\",\n \"def calculate_index_and_derivative(wl):\\n index = np.sqrt(1 + (0.6961663 * wl * wl) / (wl * wl - 0.0684043 * 0.0684043)\\n + (0.4079426 * wl * wl) / (wl * wl - 0.1162414 * 0.1162414)\\n + (0.8974794 * wl * wl) / (wl * wl - 9.896161 * 9.896161)\\n )\\n\\n index_derivative = \\\\\\n (\\n - (1.79496 * wl * wl * wl) / (pow(-97.934 + wl * wl, 2))\\n + (1.79496 * wl) / (-97.934 + wl * wl)\\n\\n - (0.815885 * wl * wl * wl) / (pow(-0.0135121 + wl * wl, 2))\\n + (0.815885 * wl) / (-0.0135121 + wl * wl)\\n\\n - (1.39233 * wl * wl * wl) / (pow(-0.00467915 + wl * wl, 2))\\n + (1.39233 * wl) / (-0.00467915 + wl * wl)\\n ) \\\\\\n / \\\\\\n (2 * np.sqrt(\\n 1\\n + (0.897479 * wl * wl) / (-97.934 + wl * wl)\\n + (0.407943 * wl * wl) / (-0.0135121 + wl * wl)\\n + (0.696166 * wl * wl) / (-0.00467915 + wl * wl)\\n )\\n )\\n return index, index_derivative\",\n \"def indices(self):\\n return range(len(self))\",\n \"def get_local_indices(self, part, ctx):\\n return self.map_to_global(\\n F.arange(0, self.local_size(part), ctx=ctx), part\\n )\",\n \"def damping_index(self):\\n start_index = self.kp_index[1]\\n end_index = start_index + self.control_dim\\n\\n if self.impedance_flag:\\n return (start_index, end_index)\\n else:\\n return None\",\n \"def comp_amplification_index(self):\\n \\n self.grid_tuning_in=self.inputs.grid_tuning_in\\n self.grid_tuning_out=gl.comp_grid_tuning_index(self.L,self.nx,(self.r[0:self.n_e**2,:]).T) \\n self.grid_tuning_out_inhib=gl.comp_grid_tuning_index(self.L,self.nx,(self.r[self.n_e**2:,:]).T)\\n\\n self.grid_amp_index=self.grid_tuning_out/self.grid_tuning_in\",\n \"def compute_tides(self):\\r\\n # take the period of the asteroid rotation\\r\\n P = self.period\\r\\n\\r\\n # compute the angle of the asteroid\\r\\n phase = 2*np.pi*(float(self.t) % P)/P\\r\\n\\r\\n # get points\\r\\n points = self.V.tabulate_dof_coordinates()[::3]\\r\\n\\r\\n # rotate points to the position they should be in, in the solar frame\\r\\n points = self.rotate_points(points, -phase)\\r\\n\\r\\n # get the acceleration, multiplies by rho\\r\\n force = float(self.rho)*self.tidal_acc(points)\\r\\n\\r\\n # rotate the force back to the actual points\\r\\n force = self.rotate_points(force, phase)\\r\\n\\r\\n # update the force function from the array\\r\\n self.ftides.vector()[:] = force.flatten()\",\n \"def get_vacancy_indices(array):\\t\\n\\tvacancy_indices = np.argwhere(array == 0)\\n\\treturn vacancy_indices\",\n \"def _get_indexes(self, participants):\\n tr_idx = int(np.floor(self.tr_size*len(participants)))\\n j = self.val_size + self.tr_size\\n val_idx = int(np.floor(j*len(participants)))\\n return tr_idx, val_idx\",\n \"def indices(self):\\n return self._kbounded_partitions\",\n \"def build_amg_index_sets(L_sizes):\\n neqns = L_sizes[0][0]\\n velocityDOF=[]\\n for start in range(1,3):\\n velocityDOF.append(np.arange(start=start,\\n stop=1+neqns,\\n step=3,\\n dtype='i'))\\n velocityDOF_full=np.vstack(velocityDOF).transpose().flatten()\\n velocity_u_DOF = []\\n velocity_u_DOF.append(np.arange(start=0,\\n stop=2*neqns//3,\\n step=2,\\n dtype='i'))\\n velocity_u_DOF_full = np.vstack(velocity_u_DOF).transpose().flatten()\\n velocity_v_DOF = []\\n velocity_v_DOF.append(np.arange(start=1,\\n stop=1+2*neqns//3,\\n step=2,\\n dtype='i'))\\n velocity_v_DOF_full = np.vstack(velocity_v_DOF).transpose().flatten()\\n isvelocity = PETSc.IS()\\n isvelocity.createGeneral(velocityDOF_full)\\n isu = PETSc.IS()\\n isu.createGeneral(velocity_u_DOF_full)\\n isv = PETSc.IS()\\n isv.createGeneral(velocity_v_DOF_full)\\n return [isvelocity, isu, isv]\",\n \"def two_dim_index(self, k):\\n ind_x = k % self.nx\\n ind_y = (k - ind_x) / self.nx\\n return (int(ind_y), int(ind_x))\",\n \"def csm_indices(csm):\\r\\n return csm_properties(csm)[1]\",\n \"def getGlobalIdxVals( self, i : int ):\\n return range(self._layout.starts[i],self._layout.ends[i])\",\n \"def get_param_indexes(self):\\n self.debug.start_function('get_param_indexes')\\n\\n for i, key in enumerate(self.mcmc_version.param_keys):\\n self.param_idxs[key] = i\\n for i, key in enumerate(self.mcmc_version.interp_keys):\\n self.interp_idxs[key] = i\\n\\n self.debug.end_function()\",\n \"def vector(self,\\n i: int,\\n j: int) -> np.ndarray:\\n return self[j].coord - self[i].coord\",\n \"def jw_number_indices(n_electrons, n_qubits):\\n occupations = itertools.combinations(range(n_qubits), n_electrons)\\n indices = [sum([2**n for n in occupation]) for occupation in occupations]\\n return indices\",\n \"def _compute_indices(self):\\n self.indices = np.arange(len(self.im_filenames))\\n np.random.shuffle(self.indices)\",\n \"def computeIndices(org_center:tuple, rot_center:tuple, xyPairs, angle, org_box_offset:tuple):\\n rot_center = np.array([[rot_center[0]], [rot_center[1]]])\\n org_center = np.array([[org_center[0]], [org_center[1]]])\\n org_box_offset = np.array([[org_box_offset[0]], [org_box_offset[1]]])\\n newPairs = xyPairs - rot_center\\n\\n rotMatrix = buildRotationMatrix(angle)\\n\\n orgPairs = np.matmul(rotMatrix, newPairs)\\n\\n return np.array(orgPairs) + org_center + org_box_offset\",\n \"def indices(self, position=None):\\n \\n raise NotImplementedError()\",\n \"def ets(self):\\n r = (self.table[0, 0] + self.table[0, 1]) * (self.table[0, 0] + self.table[1, 0]) / self.N\\n return (self.table[0, 0] - r) / (self.table[0, 0] + self.table[0, 1] + self.table[1, 0] - r)\",\n \"def _get_permutated_segments_indices(\\n self, randomized: bool, random_state: Optional[np.random.mtrand.RandomState]\\n ) -> np.ndarray:\\n idx = np.arange(self.dy.size)\\n\\n if randomized:\\n if random_state is None:\\n random_state = np.random.RandomState()\\n idx = random_state.permutation(idx)\\n return idx\",\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 indices ( self, x1, y1, z1, x2, y2, z2 ):\\n xi1, yi1, zi1 = self.index(min(x1, x2), min(y1, y2), min(z1, z2))\\n xi2, yi2, zi2 = self.index(max(x1, x2), max(y1, y2), max(z1, z2))\\n return s_[xi1:xi2+1], s_[yi1:yi2+1], s_[zi1:zi2+1]\",\n \"def surface_indices(self):\\n return self._unique_surface_indices(self.surf_mesh)\",\n \"def getVectors(self):\\n vectors = dict()\\n i = 0\\n N = len(self.db.invertedIndex)\\n for w, (idf, docs) in self.db.invertedIndex.items():\\n for doc, tf in docs.items():\\n try:\\n vectors[doc][i] = tf * idf\\n except KeyError as k:\\n vectors[doc] = {i: tf * idf}\\n i += 1\\n i = 0;\\n return vectors\",\n \"def get_indices_input_target(num_obs, input_len, step_size, forecast_horizon, target_len):\\n input_len = round(input_len) # just a precaution\\n start_position = 0\\n stop_position = num_obs - 1\\n\\n inpseq_first_idx = start_position\\n inpseq_last_idx = inpseq_first_idx + input_len\\n target_first_idx = inpseq_last_idx + forecast_horizon\\n target_last_idx = target_first_idx + target_len\\n print(\\\"target_last_idx = {}\\\".format(target_last_idx))\\n print(\\\"stop_position = {}\\\".format(stop_position))\\n indices = []\\n while target_last_idx <= stop_position:\\n indices.append((inpseq_first_idx, inpseq_last_idx, target_first_idx, target_last_idx))\\n inpseq_first_idx += step_size\\n inpseq_last_idx += step_size\\n target_first_idx += inpseq_last_idx + forecast_horizon\\n target_last_idx += target_first_idx + target_len\\n return indices\",\n \"def hoggar_indices():\\n return list(product([0,1], repeat=6))\",\n \"def getIndices(self, tokens):\\n tokenTxt, posTxt = attachTokens(tokens)\\n if tokenTxt in self.tokenIndices:\\n tokenIdx = self.tokenIndices[tokenTxt]\\n else:\\n tokenIdx = self.tokenIndices[unk]\\n if posTxt in self.posIndices:\\n posIdx = self.posIndices[posTxt]\\n else:\\n posIdx = self.posIndices[unk]\\n return tokenIdx, posIdx\",\n \"def mesh_support_idx(self, j):\\n self._ensure_mesh()\\n supp = self.support_idx(j)\\n return (self._knots_to_mesh[supp[0]], self._knots_to_mesh[supp[1]])\",\n \"def _get_index(self):\\n\\n return self.index\\n\\n # to avoid having differences bigger than 2pi\",\n \"def _iter_indices(self, frame, y):\\n pass\",\n \"def indices(self):\\n return tuple([slice(*r) for r in self.location])\",\n \"def _get_block_indices(y):\\n block_labels, block_inv, block_sizes = np.unique(\\n y, return_inverse=True, return_counts=True\\n )\\n\\n n_blocks = len(block_labels)\\n block_inds = range(n_blocks)\\n\\n block_vert_inds = []\\n for i in block_inds:\\n # get the inds from the original graph\\n inds = np.where(block_inv == i)[0]\\n block_vert_inds.append(inds)\\n return block_vert_inds, block_inds, block_inv\",\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 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 index_to_obs(a,b, grid_x, grid_y):\\n position = grid_x[a]\\n velocity = grid_y[b]\\n return position, velocity\",\n \"def compute_positions(self):\\n return (self.x + DIRECTIONS[self.facing_direction][0]) % (self.image.shape[0] - 1), \\\\\\n (self.y + DIRECTIONS[self.facing_direction][1]) % (self.image.shape[1] - 1)\",\n \"def morton_idx(pts):\\n lib = _initlib()\\n p = require(pts, dtype=float64, requirements=['C']) \\n inv_cell_width = 1.0/8192\\n npts = len(p)\\n out = empty(npts, dtype=int64)\\n lib.get_morton_idx(p, npts, inv_cell_width, out)\\n return out\",\n \"def _extract_t_indices(self, X, X2=None, dL_dK=None):\\r\\n\\r\\n # TODO: some fast checking here to see if this needs recomputing?\\r\\n self._t = X[:, 0]\\r\\n if not X.shape[1] == 2:\\r\\n raise ValueError('Input matrix for ode1 covariance should have two columns, one containing times, the other output indices')\\r\\n self._index = np.asarray(X[:, 1],dtype=np.int)\\r\\n # Sort indices so that outputs are in blocks for computational\\r\\n # convenience.\\r\\n self._order = self._index.argsort()\\r\\n self._index = self._index[self._order]\\r\\n self._t = self._t[self._order]\\r\\n self._rorder = self._order.argsort() # rorder is for reversing the order\\r\\n \\r\\n if X2 is None:\\r\\n self._t2 = None\\r\\n self._index2 = None\\r\\n self._order2 = self._order\\r\\n self._rorder2 = self._rorder\\r\\n else:\\r\\n if not X2.shape[1] == 2:\\r\\n raise ValueError('Input matrix for ode1 covariance should have two columns, one containing times, the other output indices')\\r\\n self._t2 = X2[:, 0]\\r\\n self._index2 = np.asarray(X2[:, 1],dtype=np.int)\\r\\n self._order2 = self._index2.argsort()\\r\\n self._index2 = self._index2[self._order2]\\r\\n self._t2 = self._t2[self._order2]\\r\\n self._rorder2 = self._order2.argsort() # rorder2 is for reversing order\\r\\n\\r\\n if dL_dK is not None:\\r\\n self._dL_dK = dL_dK[self._order, :]\\r\\n self._dL_dK = self._dL_dK[:, self._order2]\",\n \"def getstate(self):\\r\\n return [self.tied_indices,\\r\\n self.fixed_indices,\\r\\n self.fixed_values,\\r\\n self.constrained_indices,\\r\\n self.constraints]\",\n \"def get_img_indices():\\n if K.image_dim_ordering() == 'th':\\n return 0, 1, 2, 3\\n else:\\n return 0, 3, 1, 2\",\n \"def _fixed_indicies(self):\\n fixed_inds = self.constraints == 'fixed'\\n return fixed_inds\",\n \"def create_vectors(self):\\n self.localStatistics = []\\n self.lastStatistics = []\\n self.globalV = []\\n self.estimate = []\\n self.delta = []\\n self.drift = []\\n self.slack = [] # only for coordBased model\",\n \"def test_y_vector_init(self):\\n # If you change the y-vector ordering, change here too #Y_VECTOR_CHANGESITE\\n\\n eng_fields = np.zeros(EngineeringState.N_ENGINEERING_FIELDS)\\n component_array = eng_fields[EngineeringState._COMPONENT_START_INDEX:EngineeringState._COMPONENT_END_INDEX]\\n for comp_i in range(0, N_COMPONENTS):\\n component_array[comp_i + N_COMPONENTS * 0] = True # connected\\n component_array[comp_i + N_COMPONENTS * 1] = 1 + (0.01 * comp_i) # capacity\\n component_array[comp_i + N_COMPONENTS * 2] = 222200 + comp_i # temperature\\n component_array[comp_i + N_COMPONENTS * 3] = comp_i % 2 # coolant_hab_one\\n component_array[comp_i + N_COMPONENTS * 4] = True # coolant_hab_two\\n component_array[comp_i + N_COMPONENTS * 5] = False # coolant_ayse\\n\\n coolant_array = eng_fields[EngineeringState._COOLANT_START_INDEX:EngineeringState._COOLANT_END_INDEX]\\n for cool_i in range(0, N_COOLANT_LOOPS):\\n coolant_array[cool_i + N_COOLANT_LOOPS * 0] = 555500 + cool_i # coolant_temp\\n coolant_array[cool_i + N_COOLANT_LOOPS * 1] = cool_i % 2 # primary_pump_on\\n coolant_array[cool_i + N_COOLANT_LOOPS * 2] = True # secondary_pump_on\\n\\n rad_array = eng_fields[EngineeringState._RADIATOR_START_INDEX:EngineeringState._RADIATOR_END_INDEX]\\n for rad_i in range(0, N_RADIATORS):\\n rad_array[rad_i + N_RADIATORS * 0] = rad_i % 4 # attached_to_coolant_loop\\n rad_array[rad_i + N_RADIATORS * 1] = rad_i % 2 # functioning\\n\\n y0 = np.concatenate((np.array([\\n 0x111, 0x222, # x\\n 0x333, 0x444, # y\\n 0x555, 0x777, # vx\\n 0x888, 0x999, # vy\\n 0.01, 0.02, # heading\\n 0.03, 0.04, # spin\\n 0xEEE, 0xFFF, # fuel\\n 5, 6, # throttle\\n 1, -1, # only First is landed on Second\\n 0, 1, # Second is broken\\n common.SRB_EMPTY,\\n 1 # time_acc\\n ]),\\n eng_fields\\n ))\\n\\n ps = PhysicsState(y0, self.proto_state)\\n self.assertTrue(np.array_equal(ps.y0(), y0.astype(ps.y0().dtype)))\\n self.assertEqual(ps['First'].landed_on, 'Second')\\n\\n proto_state = ps.as_proto()\\n proto_state.timestamp = 50\\n self.assertEqual(proto_state.entities[0].x, 0x111)\\n self.assertEqual(proto_state.entities[0].y, 0x333)\\n self.assertEqual(proto_state.entities[1].x, 0x222)\\n self.assertEqual(proto_state.entities[1].y, 0x444)\\n self.assertEqual(proto_state.entities[0].vx, 0x555)\\n self.assertEqual(proto_state.entities[0].vy, 0x888)\\n self.assertEqual(proto_state.entities[1].vx, 0x777)\\n self.assertEqual(proto_state.entities[1].vy, 0x999)\\n self.assertEqual(proto_state.entities[0].heading, 0.01)\\n self.assertEqual(proto_state.entities[1].heading, 0.02)\\n self.assertEqual(proto_state.entities[0].spin, 0.03)\\n self.assertEqual(proto_state.entities[1].spin, 0.04)\\n self.assertEqual(proto_state.entities[0].fuel, 0xEEE)\\n self.assertEqual(proto_state.entities[1].fuel, 0xFFF)\\n self.assertEqual(proto_state.entities[0].landed_on, 'Second')\\n self.assertEqual(proto_state.entities[1].landed_on, '')\\n self.assertEqual(proto_state.timestamp, 50)\\n self.assertTrue(proto_state.entities[1].broken)\\n\\n for i, component in enumerate(ps.engineering.components):\\n self.assertEqual(component.connected, True, msg=i)\\n self.assertEqual(component.capacity, 1 + (0.01 * i), msg=i)\\n self.assertEqual(component.temperature, 222200 + i, msg=i)\\n self.assertEqual(component.coolant_hab_one, bool(i % 2), msg=i)\\n self.assertEqual(component.coolant_hab_two, True, msg=i)\\n self.assertEqual(component.coolant_ayse, False, msg=i)\\n\\n for i, coolant in enumerate(ps.engineering.coolant_loops):\\n self.assertEqual(coolant.coolant_temp, 555500 + i, msg=i)\\n self.assertEqual(coolant.primary_pump_on, bool(i % 2), msg=i)\\n self.assertEqual(coolant.secondary_pump_on, True, msg=i)\\n\\n for i, radiator in enumerate(ps.engineering.radiators):\\n pass\\n self.assertEqual(radiator.attached_to_coolant_loop, i % 4, msg=i)\\n self.assertEqual(radiator.functioning, bool(i % 2), msg=i)\",\n \"def _get_block_indices(y: np.ndarray) -> Tuple[List[np.ndarray], range, np.ndarray]:\\n block_labels: np.ndarray\\n block_inv: np.ndarray\\n block_sizes: np.ndarray\\n block_labels, block_inv, block_sizes = np.unique(\\n y, return_inverse=True, return_counts=True\\n )\\n\\n n_blocks = len(block_labels)\\n block_inds = range(n_blocks)\\n\\n block_vert_inds = []\\n for i in block_inds:\\n # get the inds from the original graph\\n inds = np.where(block_inv == i)[0]\\n block_vert_inds.append(inds)\\n return block_vert_inds, block_inds, block_inv\",\n \"def expandcal(self):\\n ind=np.zeros(self.spec.shape[0]).astype(int)\\n for k in range(self.nscan):\\n ind[self.getscanind(k)]=k\\n ind[self.getcalind(k)]=k\\n return ind\",\n \"def velocities(self, return_np=False):\\n if return_np:\\n return self.si_values()[3:]\\n return [self.v_x, self.v_y, self.v_z]\",\n \"def min_indices(self):\\n return {term.minterm_index for term in self.iter_minterms()}\",\n \"def indices(self, _user=None):\\n return [p.index for p in self.get_active_smallvariant_cases()]\",\n \"def box_collision_info(self):\\r\\n position = np.zeros((self.Npart,3)) # antall part, dim, iterasjoner\\r\\n position[:,:] = np.random.uniform(0,1e-6, size = (self.Npart,3))\\r\\n velocity = np.zeros((self.Npart,3))\\r\\n velocity[:,:] = np.random.normal(0,self.sigma,size = (self.Npart,3))\\r\\n\\r\\n part_collided = 0\\r\\n part_escaped = 0\\r\\n momentum = 0\\r\\n\\r\\n print 'engine started'\\r\\n for i in xrange(1,self.n):\\r\\n #collision\\r\\n position += velocity*dt\\r\\n l_hole = position[:,0:2] > self.L/4\\r\\n h_hole = position[:,0:2] < (3*self.L)/4\\r\\n pos_xy = np.logical_and(l_hole, h_hole)\\r\\n pos_xy = np.logical_and(pos_xy[:,0], pos_xy[:,1])\\r\\n pos_z = position[:,2] < 0\\r\\n esc_part = np.logical_and(pos_z, pos_xy)\\r\\n\\r\\n #velocity[esc_part] = velocity[esc_part]\\r\\n part_escaped += np.sum(esc_part)\\r\\n\\r\\n for j in xrange(0,3):\\r\\n impact_wall_pos = np.logical_and(position[:,j] > 0,\\r\\n position[:,j] < self.L)\\r\\n velocity[np.logical_not(impact_wall_pos),j] = -velocity[\\r\\n np.logical_not(impact_wall_pos),j]\\r\\n\\r\\n\\r\\n if j == 0:\\r\\n part_collided += np.sum(np.logical_not(impact_wall_pos),j)\\r\\n momentum += np.sum(2*self.m*abs(velocity[np.logical_not(\\r\\n impact_wall_pos),j]))\\r\\n\\r\\n\\r\\n\\r\\n position[position < 0] = 0\\r\\n position[position >self.L] = self.L\\r\\n\\r\\n particle_collided = part_collided/2\\r\\n return position, velocity,part_escaped, impact_wall_pos, particle_collided, momentum\",\n \"def get_indexes(self):\\n indexes = []\\n for c in self.components:\\n indexes.extend(c.get_indexes())\\n return indexes\",\n \"def vector(molec, dihed, nonH, energy):\\n #Torison\\n if dihed:\\n pass\\n #XYZ\\n else:\\n coords = ()\\n if nonH:\\n for atom in molec.atoms:\\n coords += atom.coords\\n else:\\n for atom in molec.atoms:\\n if atom.atomicnum > 1:\\n coords += atom.coords\\n #Energy\\n if energy:\\n coords += (molec.energy/10.0,)\\n return coords\",\n \"def get_final_pruned_indices(self):\\n return self.final_pruned_indices\",\n \"def calculate_useful_stuff(self):\\n\\n self.pos = self.pair[1].position - self.pair[0].position\\n self.vel = self.pair[1].velocity - self.pair[0].velocity\\n\\n self.r = self.pos.length()\\n self.v = self.vel.length()\\n self.inv_r = 1.0 / self.r\\n\\n self.rvec = self.pos * self.inv_r\\n self.rdot = (self.rvec * self.vel).sum() * self.rvec\\n self.rdot_mag = self.rdot.length()\\n\\n self.vth = self.vel - self.rdot\\n self.vth_mag = self.vth.length()\\n self.vth_vec = self.vth / self.vth_mag\",\n \"def velocity_field(self):\\n return scipy.dstack((self._u_int, self._v_int))\",\n \"def get_segment_index(datadb):\\n #match in time!!!!\\n if cfg.use_saliency:\\n segment_index_tar = util.get_time_for_visual(datadb)\\n segment_index_tar_future = OrderedDict()\\n for key in segment_index_tar.keys():\\n segment_index_tar_future[key] = np.array(segment_index_tar[key])+max_encoder_seq_length\\n return segment_index_tar,segment_index_tar_future\",\n \"def get_ecc(self):\\n mu_mass = G*(self._mm + self._sm)\\n h_mom = self.sp_ang_mom()\\n vel = self.getvel_xyz()\\n pos = self.getpos_xyz()\\n e_vec = 1.0/mu_mass*(np.cross(vel, h_mom) -\\n mu_mass*pos/np.linalg.norm(pos))\\n return e_vec\",\n \"def calc_index(self, x, y, model, variable, weights=None, time_weighting=True):\\n\\n if weights is None:\\n # set weights according to cell area\\n if x.cell_area is not None:\\n weights = x._get_weighting_matrix()\\n else:\\n print('WARNING: no weights when calculating performance index')\\n weights = np.ones(x.data.shape)\\n else: # weights are given\\n if x.cell_area is not None:\\n print('WARNING: cell weights are given, while cell_area available from data!!')\\n\\n from pycmbs.diagnostic import Diagnostic\\n D = Diagnostic(x, y=y)\\n # reichler performance index\\n # (might return a list if multiple times analyzed)\\n e2 = D.calc_reichler_index(weights) # returns [time, index]\\n if e2 is not None:\\n e2 = np.ma.masked_where(np.isnan(e2), e2)\\n\\n # Note that the returned value is E**2 for each timestep!\\n # When doing the normalization, one needs to take the sqrt(E++2)\\n # to obtain the actual RMSE\\n if e2 is None:\\n return None\\n else:\\n if time_weighting:\\n days = np.asarray(x._days_per_month()) # number of days for each month\\n wt = days / float(days.sum()) # weights for time\\n else:\\n wt = np.ones(len(e2)) / float(len(e2))\\n\\n return np.sqrt((e2 * wt).sum())\",\n \"def get_uncut_indices(atoms, orig, vec1, offset=None):\\n\\n if isinstance(orig, int):\\n orig = atoms.get_positions()[orig]\\n else:\\n orig = np.array(orig)\\n if isinstance(vec1, int):\\n vec1 = atoms.get_positions()[vec1]\\n else:\\n vec1 = np.array(vec1)\\n\\n# if vec2 and isinstance(vec2, int):\\n# vec2 = atoms.get_positions()[vec2]\\n# elif vec2:\\n# vec2 = np.array(vec2)\\n# if vec3 and isinstance(vec3, int):\\n# vec3 = atoms.get_positions()[vec3]\\n# elif vec3:\\n# vec3 = np.array(vec3)\\n#\\n# if vec2:\\n# plane_vec = np.cross(vec1-orig, vec2-orig)\\n# else:\\n# plane_vec = vec1-orig\\n#\\n# nplane_vec = plane_vec/np.linalg.norm(plane_vec)\\n#\\n# if vec2 and vec3 and nplane_vec.dot(vec3-orig) < 0:\\n# nplane_vec *= -1\\n\\n plane_vec = vec1 - orig\\n nplane_vec = plane_vec/np.linalg.norm(plane_vec)\\n\\n if offset:\\n orig += offset*nplane_vec\\n\\n atom_indices = [i for i,a in enumerate(atoms) if (a.position - orig).dot(nplane_vec) > 0]\\n return atom_indices\",\n \"def _index(self, i, j):\\n assert self._isvalid(i), 'i term (%s) is out of bounds' % i\\n assert self._isvalid(j), 'j term (%s) is out of bounds' % j\\n\\n return self.n * (i - 1) + (j - 1)\",\n \"def compute_idx(pos, edge_index):\\n\\n pos_i = pos[edge_index[0]]\\n pos_j = pos[edge_index[1]]\\n\\n d_ij = torch.norm(abs(pos_j - pos_i), dim=-1, keepdim=False).unsqueeze(-1) + 1e-5\\n v_ji = (pos_i - pos_j) / d_ij\\n\\n unique, counts = torch.unique(\\n edge_index[0], sorted=True, return_counts=True\\n ) # Get central values\\n full_index = (\\n torch.arange(0, edge_index[0].size()[0]).cuda().int()\\n ) # init full index\\n\\n # Compute 1\\n repeat = torch.repeat_interleave(counts, counts)\\n counts_repeat1 = torch.repeat_interleave(full_index, repeat) # 0,...,0,1,...,1,...\\n\\n # Compute 2\\n split = torch.split(full_index, counts.tolist()) # split full index\\n index2 = list(edge_index[0].data.cpu().numpy()) # get repeat index\\n counts_repeat2 = torch.cat(itemgetter(*index2)(split), dim=0) # 0,1,2,...,0,1,2,..\\n\\n # Compute angle embeddings\\n v1 = v_ji[counts_repeat1.long()]\\n v2 = v_ji[counts_repeat2.long()]\\n\\n angle = (v1 * v2).sum(-1).unsqueeze(-1)\\n angle = torch.clamp(angle, min=-1.0, max=1.0) + 1e-6 + 1.0\\n\\n return counts_repeat1.long(), counts_repeat2.long(), angle\",\n \"def _getitem2d(self, index):\\n\\n lovects = self._getlovects()\\n hivects = self._gethivects()\\n fields = self._getfields()\\n\\n ix = index[0]\\n iz = index[1]\\n\\n if len(fields[0].shape) > self.dim:\\n ncomps = fields[0].shape[-1]\\n else:\\n ncomps = 1\\n\\n if len(index) > self.dim:\\n if ncomps > 1:\\n ic = index[2]\\n else:\\n raise Exception('Too many indices given')\\n else:\\n ic = None\\n\\n nx = hivects[0,:].max() - self.nghosts\\n nz = hivects[1,:].max() - self.nghosts\\n\\n if npes > 1:\\n nx = comm_world.allreduce(nx, op=mpi.MAX)\\n nz = comm_world.allreduce(nz, op=mpi.MAX)\\n\\n if isinstance(ix, slice):\\n ixstart = max(ix.start or -self.nghosts, -self.nghosts)\\n ixstop = min(ix.stop or nx + 1 + self.nghosts, nx + self.overlaps[0] + self.nghosts)\\n else:\\n ixstart = ix\\n ixstop = ix + 1\\n if isinstance(iz, slice):\\n izstart = max(iz.start or -self.nghosts, -self.nghosts)\\n izstop = min(iz.stop or nz + 1 + self.nghosts, nz + self.overlaps[1] + self.nghosts)\\n else:\\n izstart = iz\\n izstop = iz + 1\\n\\n # --- Setup the size of the array to be returned and create it.\\n # --- Space is added for multiple components if needed.\\n sss = (max(0, ixstop - ixstart),\\n max(0, izstop - izstart))\\n if ncomps > 1 and ic is None:\\n sss = tuple(list(sss) + [ncomps])\\n resultglobal = np.zeros(sss, dtype=_libwarpx._numpy_real_dtype)\\n\\n datalist = []\\n for i in range(len(fields)):\\n\\n # --- The ix1, 2 etc are relative to global indexing\\n ix1 = max(ixstart, lovects[0,i])\\n ix2 = min(ixstop, lovects[0,i] + fields[i].shape[0])\\n iz1 = max(izstart, lovects[1,i])\\n iz2 = min(izstop, lovects[1,i] + fields[i].shape[1])\\n\\n if ix1 < ix2 and iz1 < iz2:\\n\\n sss = (slice(ix1 - lovects[0,i], ix2 - lovects[0,i]),\\n slice(iz1 - lovects[1,i], iz2 - lovects[1,i]))\\n if ic is not None:\\n sss = tuple(list(sss) + [ic])\\n\\n vslice = (slice(ix1 - ixstart, ix2 - ixstart),\\n slice(iz1 - izstart, iz2 - izstart))\\n\\n datalist.append((vslice, fields[i][sss]))\\n\\n if npes == 1:\\n all_datalist = [datalist]\\n else:\\n all_datalist = comm_world.allgather(datalist)\\n\\n for datalist in all_datalist:\\n for vslice, ff in datalist:\\n resultglobal[vslice] = ff\\n\\n # --- Now remove any of the reduced dimensions.\\n sss = [slice(None), slice(None)]\\n if not isinstance(ix, slice):\\n sss[0] = 0\\n if not isinstance(iz, slice):\\n sss[1] = 0\\n\\n return resultglobal[tuple(sss)]\",\n \"def agent_locs_idx(self):\\n return tuple(self.agent_locs.T)\",\n \"def _position_and_velocity(self, jd):\\n pos, vel = terra(self.latitude.radians, self.longitude.radians,\\n self.elevation.au, jd.gast)\\n pos = einsum('ij...,j...->i...', jd.MT, pos)\\n vel = einsum('ij...,j...->i...', jd.MT, vel)\\n return pos, vel\",\n \"def indices_hkl(self, H, K, L):\\n from cctbx import miller\\n _symm_equiv = miller.sym_equiv_indices(self.sg, (H, K, L))\\n _indices = sorted([i.h() for i in _symm_equiv.indices()],\\n reverse=True)\\n if len(_indices) < _symm_equiv.multiplicity(False):\\n _indices = _indices + [(-hh, -kk, -ll)\\n for (hh, kk, ll) in _indices]\\n return _indices\",\n \"def get_analytical_accelerations(self):\\n # create empty numpy array for accelerations\\n accelerations = np.zeros((3, len(self.times)))\\n # radial accelerations is equal to angular velocity^2 / radius but radius is unitary is this trajectory\\n radial_acceleration = self.wz ** 2\\n # decompose radial accelerations in x and y components\\n accelerations[0, :] = radial_acceleration * -cos(self.th[:, 2])\\n accelerations[1, :] = radial_acceleration * -sin(self.th[:, 2])\\n # accelerations along x axis is constant\\n accelerations[2, :] = self.ax\\n return accelerations\",\n \"def _get_valid_indices(\\n self,\\n _signals: np.ndarray,\\n _labels: np.ndarray,\\n window_start_indices: np.ndarray = None,\\n elm_start_indices: np.ndarray = None,\\n elm_stop_indices: np.ndarray = None,\\n valid_t0: np.ndarray = None,\\n labels: np.ndarray = None,\\n signals: np.ndarray = None,\\n ) -> Tuple[\\n np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray\\n ]:\\n # allowed indices; time data points which can be used for creating the data chunks\\n _valid_t0 = np.ones(_labels.shape, dtype=np.int32)\\n _valid_t0[\\n -(config.signal_window_size + config.label_look_ahead) + 1 :\\n ] = 0\\n\\n # indices for active elm events in each elm event\\n active_elm_events = np.nonzero(_labels >= 0.5)[0]\\n\\n if signals is None:\\n # initialize arrays\\n window_start_indices = np.array([0])\\n elm_start_indices = active_elm_events[0]\\n elm_stop_indices = active_elm_events[-1]\\n valid_t0 = _valid_t0\\n signals = _signals\\n labels = _labels\\n else:\\n # concat on axis 0 (time dimension)\\n last_index = len(labels) - 1\\n window_start_indices = np.append(\\n window_start_indices, last_index + 1\\n )\\n elm_start_indices = np.append(\\n elm_start_indices, active_elm_events[0] + last_index + 1\\n )\\n elm_stop_indices = np.append(\\n elm_stop_indices, active_elm_events[-1] + last_index + 1\\n )\\n valid_t0 = np.concatenate([valid_t0, _valid_t0])\\n signals = np.concatenate([signals, _signals], axis=0)\\n labels = np.concatenate([labels, _labels], axis=0)\\n\\n return (\\n signals,\\n labels,\\n valid_t0,\\n window_start_indices,\\n elm_start_indices,\\n elm_stop_indices,\\n )\",\n \"def cal_globalIndexH(self):\\n h_local = self.cal_localIndexH()\\n h_global = np.sum(h_local)\\n\\n return h_global\",\n \"def indices(self):\\n if self._indices is None:\\n i = []\\n\\n # TODO: this is not right for multi-column keys\\n # TODO: new style indexes\\n\\n global_name = '^DD(%s,0,\\\"IX\\\",\\\"0\\\")' % self.fileid\\n prefix = '^DD(%s,0,\\\"IX\\\",' % self.fileid\\n while 1:\\n global_name = M.mexec('set s0=$query(%s)' % global_name, M.INOUT(\\\"\\\"))[0]\\n if not global_name or not global_name.startswith(prefix):\\n break\\n suffix = global_name[len(prefix):-1]\\n parts = suffix.split(\\\",\\\")\\n idx_name = parts[0][1:-1]\\n idx_table = parts[1]\\n idx_columns = parts[2:]\\n index = Index(idx_name, idx_table, idx_columns)\\n i.append(index)\\n\\n # A second list, gives indices for a field\\n columns = {}\\n for idx in i:\\n for c in idx.columns:\\n columns[c] = 1\\n\\n # Now trawl the listed columns in the data dictionary, and load their\\n # cross references.\\n cr_names = {}\\n for c in columns.keys():\\n idx_root = M.Globals[\\\"^DD\\\"][self.fileid][c][1]\\n if not idx_root[0].exists():\\n continue\\n for cr_id, val in idx_root.keys_with_decendants():\\n if float(cr_id) > 0:\\n cr_header = idx_root[cr_id][0].value\\n parts = cr_header.split(\\\"^\\\")\\n if len(parts) == 2 and parts[1]: # if more than 2 parts, assume MUMPs trigger\\n f = cr_names.get(parts[1], list())\\n f.append(c)\\n cr_names[parts[1]] = f\\n\\n # Now, just delete items from the index list if they are not in cr_names\\n self._indices = []\\n for index in i:\\n cr = cr_names.get(index.name)\\n if cr:\\n # verify columns - lots of errors in real systems\\n if len(cr) == len(index.columns):\\n invalid = False\\n for c in cr:\\n if c not in index.columns:\\n invalid = True\\n continue\\n if not invalid:\\n self._indices.append(index)\\n\\n return self._indices\",\n \"def calcAllIntensities(self, xc, yc):\\n\\n tp = 0.0\\n ix = 0\\n iy = 0\\n h = 0\\n ints = np.zeros([5, 5])\\n ints_inner = np.zeros([5, 5])\\n # ints = [[0.0] * 5] * 5\\n # ints_inner = [[0.0] * 5] * 5\\n x = 0.0\\n y = 0.0\\n xc1 = 0.0\\n yc1 = 0.0\\n xc1 = xc\\n yc1 = yc\\n \\n for h in np.arange(1,5,1):\\n for k in np.arange(1,5,1):\\n ints[h][k] = 0.0\\n ints_inner[h][k] = 0.0\\n\\n for k in np.arange(0, 2, 1):\\n for h in np.arange(0, 2, 1):\\n for ix in np.arange(0, self.stepp + 1, 1):\\n for iy in np.arange(0, self.stepp + 1, 1):\\n #print(k, h, ix, iy)\\n if self.qc_format == 0 :\\n x = -(1 + self.G) + h * (1 + 2 * self.G) + (ix * (1.0 / self.stepp))\\n y = -(1 + self.G) + k * (1 + 2 * self.G) + (iy * (1.0 / self.stepp))\\n if self.spot_radius == 0 or math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)) == 0 :\\n tp = 0.0\\n else :\\n tp = (math.sin((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))) / ((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))\\n tp = math.pow(tp,2)\\n #print(tp)\\n elif self.qc_format == 1 :\\n x = -1 + h + (ix * (1 / self.stepp))\\n y = -1 + k + (iy * (1 / self.stepp))\\n ints[h + 1][k + 1] += math.pow(math.exp((math.pow((x - xc1),2) + math.pow((y - yc1),2) ) / math.pow(self.spot_radius,2)), -1)\\n if (self.spot_radius * self.spot_radius) == 0 or ((x - xc1) * (y - yc1) * np.pi * np.pi) == 0 :\\n tp = 0.0\\n else :\\n tp = (math.sin((x - xc1) * np.pi / self.spot_radius) * math.sin((y - yc1) * np.pi / self.spot_radius)) / (((x - xc1) * (y - yc1) * np.pi * np.pi) / (self.spot_radius * self.spot_radius))\\n\\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.radius_inner,2):\\n ints_inner[h + 1][k + 1] += tp\\n else :\\n if self.qc_format == 1 :\\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.cell_qc, 2):\\n ints[h + 1][k + 1] += tp\\n if (math.pow(x,2) + math.pow(y,2)) <= 1 :\\n #print(math.pow(x,2) + math.pow(y,2))\\n ints[h + 1][k + 1] += tp\\n # print(ints[h + 1][k + 1])\\t\\t\\t\\t\\t\\t\\n tp = 0.0\\n\\n # print(ints)\\n\\n Aq = 0.0\\n Bq = 0.0\\n Cq = 0.0\\n Dq = 0.0\\n Ac_inner = 0.0\\n Bc_inner = 0.0\\n Cc_inner = 0.0\\n Dc_inner = 0.0\\n Ac = 0.0\\n Bc = 0.0\\n Cc = 0.0\\n Dc = 0.0\\n Ac = ints[1][2]\\n Bc = ints[2][2]\\n Cc = ints[2][1]\\n Dc = ints[1][1]\\n\\n Ac_inner = ints_inner[1][2]\\n Bc_inner = ints_inner[2][2]\\n Cc_inner = ints_inner[2][1]\\n Dc_inner = ints_inner[1][1]\\n Ac *= self.QE\\n Bc *= self.QE\\n Cc *= self.QE\\n Dc *= self.QE\\n\\n Ac_inner *= self.QE_inner\\n Bc_inner *= self.QE_inner\\n Cc_inner *= self.QE_inner\\n Dc_inner *= self.QE_inner\\n Ac += Ac_inner\\n Bc += Bc_inner\\n Cc += Cc_inner\\n Dc += Dc_inner\\n\\n Aq = Ac\\n Bq = Bc\\n Cq = Cc\\n Dq = Dc\\n\\n #tp/TP = cotribution percentage of the spot with respect to max (spot center)\\n if self.smooth == 0 :\\n if (Config.hplk_c0_e * self.TP) == 0 :\\n cnst = 0\\n else :\\n cnst = ((Parameters.TPS / (self.n_ml * self.n_ml)) * self.lamb) / (Config.hplk_c0_e * self.TP) #Número de fótons efeticos\\n if Config.flag_spice == 1 :\\n Ac *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP) #W\\n Bc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\\n Cc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\\n Dc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\\n Ac *= 1 / (math.pow(self.cell_qc * 1e-6,2)) #W/(m^2)\\n Bc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\\n Cc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\\n Dc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\\n #Ac *= 1 / (self.lamb * 1e6); #Adequação da irradiância para a unidade W/m2micm conforme necessário no SPICE\\n #Bc *= 1 / (self.lamb * 1e6);\\n #Cc *= 1 / (self.lamb * 1e6);\\n #Dc *= 1 / (self.lamb * 1e6);\\n \\n ############################## DOUBLE CHECK ##############################\\n # self.grava_arquivos = 1\\n # self.flag_V_QC = 0\\n # grava_le_arquivos(0) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\\n # self.flag_V_QC = 1\\n # self.grava_arquivos = 0\\n ############################## DOUBLE CHECK ##############################\\n Aq *= cnst * 1e9\\n Bq *= cnst * 1e9\\n Cq *= cnst * 1e9\\n Dq *= cnst * 1e9\\n else :\\n Aq *= cnst * 1e9\\n Bq *= cnst * 1e9\\n Cq *= cnst * 1e9\\n Dq *= cnst * 1e9\\n\\n # 'returns' all the intensities\\n self.A_intensity = Aq\\n self.B_intensity = Bq\\n self.C_intensity = Cq\\n self.D_intensity = Dq\",\n \"def atom_idxs(self):\\n\\n return np.array([atom.atom_idxs for atom in self])\",\n \"def crearIndices(self):\\n l = self.encontrarCaracteres()\\n i=0\\n for c in l:\\n self.indices[c] = i\\n i+=1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70425975","0.6227534","0.621245","0.61198896","0.6050179","0.60492086","0.59963256","0.59747845","0.5971784","0.5960889","0.5925465","0.5918824","0.5916217","0.5899766","0.5848567","0.5788059","0.5782234","0.5770706","0.5726879","0.5722692","0.5709878","0.5705728","0.5678939","0.5640984","0.5640419","0.5631342","0.5630303","0.56163704","0.55861324","0.55519974","0.5551183","0.55342984","0.55268997","0.55034244","0.54960686","0.54851276","0.54804283","0.54672045","0.54626197","0.5453842","0.5436701","0.54277575","0.5420072","0.5420071","0.5402086","0.5392326","0.53901404","0.5388624","0.53812534","0.53764254","0.5366359","0.53615344","0.5357011","0.5334793","0.5325488","0.5317872","0.5317858","0.53114384","0.5310661","0.5300275","0.52820843","0.5279397","0.5275549","0.5270516","0.5268178","0.5264593","0.52638525","0.52607495","0.5260732","0.52568746","0.52547526","0.525471","0.525142","0.525029","0.5249663","0.52496094","0.5248935","0.5228188","0.5226314","0.52187985","0.5218281","0.5217674","0.5206792","0.52056205","0.5193406","0.5192475","0.5186248","0.51860255","0.51827234","0.5180917","0.5180642","0.51799184","0.5179198","0.5176682","0.51688766","0.5163929","0.51629454","0.5161684","0.5153994","0.5152692","0.51501006"],"string":"[\n \"0.70425975\",\n \"0.6227534\",\n \"0.621245\",\n \"0.61198896\",\n \"0.6050179\",\n \"0.60492086\",\n \"0.59963256\",\n \"0.59747845\",\n \"0.5971784\",\n \"0.5960889\",\n \"0.5925465\",\n \"0.5918824\",\n \"0.5916217\",\n \"0.5899766\",\n \"0.5848567\",\n \"0.5788059\",\n \"0.5782234\",\n \"0.5770706\",\n \"0.5726879\",\n \"0.5722692\",\n \"0.5709878\",\n \"0.5705728\",\n \"0.5678939\",\n \"0.5640984\",\n \"0.5640419\",\n \"0.5631342\",\n \"0.5630303\",\n \"0.56163704\",\n \"0.55861324\",\n \"0.55519974\",\n \"0.5551183\",\n \"0.55342984\",\n \"0.55268997\",\n \"0.55034244\",\n \"0.54960686\",\n \"0.54851276\",\n \"0.54804283\",\n \"0.54672045\",\n \"0.54626197\",\n \"0.5453842\",\n \"0.5436701\",\n \"0.54277575\",\n \"0.5420072\",\n \"0.5420071\",\n \"0.5402086\",\n \"0.5392326\",\n \"0.53901404\",\n \"0.5388624\",\n \"0.53812534\",\n \"0.53764254\",\n \"0.5366359\",\n \"0.53615344\",\n \"0.5357011\",\n \"0.5334793\",\n \"0.5325488\",\n \"0.5317872\",\n \"0.5317858\",\n \"0.53114384\",\n \"0.5310661\",\n \"0.5300275\",\n \"0.52820843\",\n \"0.5279397\",\n \"0.5275549\",\n \"0.5270516\",\n \"0.5268178\",\n \"0.5264593\",\n \"0.52638525\",\n \"0.52607495\",\n \"0.5260732\",\n \"0.52568746\",\n \"0.52547526\",\n \"0.525471\",\n \"0.525142\",\n \"0.525029\",\n \"0.5249663\",\n \"0.52496094\",\n \"0.5248935\",\n \"0.5228188\",\n \"0.5226314\",\n \"0.52187985\",\n \"0.5218281\",\n \"0.5217674\",\n \"0.5206792\",\n \"0.52056205\",\n \"0.5193406\",\n \"0.5192475\",\n \"0.5186248\",\n \"0.51860255\",\n \"0.51827234\",\n \"0.5180917\",\n \"0.5180642\",\n \"0.51799184\",\n \"0.5179198\",\n \"0.5176682\",\n \"0.51688766\",\n \"0.5163929\",\n \"0.51629454\",\n \"0.5161684\",\n \"0.5153994\",\n \"0.5152692\",\n \"0.51501006\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":87197,"cells":{"query":{"kind":"string","value":"Compute and set the additional terms to fix the boundary values."},"document":{"kind":"string","value":"def set_rhs(self):\n k = self.istore[:, 0]\n ksym = self.stencil.get_symmetric()[k]\n self.rhs[:] = self.feq[k, np.arange(k.size)] - self.feq[ksym, np.arange(k.size)]"},"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 calculateElementBoundaryCoefficients(self):\n pass","def update(self):\n\n terms_toRemove = []\n\n for termIndex, [term_constantFactor, term_unknowns_attributeAddresses] in enumerate(self.LHS):\n\n # Check if coefficient is 0 - then no need to process any of the unknowns since term will be 0 anyways\n if term_constantFactor == 0:\n terms_toRemove.append(termIndex)\n continue # continue to next term, no need to resolve the unknowns of this term since the product will be 0 anyways\n\n # Check if any unknowns became known\n unknowns_toRemove = []\n for unknown_attributeAddress in term_unknowns_attributeAddresses:\n attribute = getattr_fromAddress(*unknown_attributeAddress)\n if isNumeric(attribute):\n # object.attribute which had previously been identified as unknown now has a value, add it to the constant factor product and remove from the unknowns\n self.LHS[termIndex][0] *= attribute # multiply it with the constant factor product\n unknowns_toRemove.append([termIndex, unknown_attributeAddress])\n for termIndex, unknown_attributeAddress in unknowns_toRemove: # remove unknowns which have become known in the end\n # removing in the end not to tamper with the iteration of the above loop\n self.LHS[termIndex][1].remove(unknown_attributeAddress)\n\n # Move constants to RHS\n if self.LHS[termIndex][1] == []:\n # if term has no unknowns, it is a constant, move to RHS\n self.RHS -= self.LHS[termIndex][0]\n self.LHS.pop(termIndex)\n\n for termIndex in reversed(terms_toRemove): # reversed - otherwise would tamper with indices of items identified for removal\n self.LHS.pop(termIndex)\n\n self._gatherUnknowns()","def boundary_conditions(self):\n ce = 2 * self.dy * self.g * self.mu * self.m_u / self.kb\n self.e[0, :] = (4 * self.e[1, :] - self.e[2, :]) / (\n ce / self.T[0, :] + 3\n )\n self.rho[0, :] = (\n self.e[0, :]\n * (self.Y - 1)\n * self.mu\n * self.m_u\n / (self.kb * self.T[0, :])\n )\n self.u[0, :] = (4 * self.u[1, :] - self.u[2, :]) / 3\n self.w[0, :] = 0\n\n self.e[-1, :] = (4 * self.e[-2, :] - self.e[-3, :]) / (\n 3 - ce / self.T[-1, :]\n )\n self.rho[-1, :] = (\n self.e[-1, :]\n * (self.Y - 1)\n * self.mu\n * self.m_u\n / (self.kb * self.T[-1, :])\n )\n self.u[-1, :] = (4 * self.u[-2, :] - self.u[-3, :]) / 3\n self.w[-1, :] = 0","def set_internal_boundary_conditions(self, model):\n\n def boundary_gradient(left_symbol, right_symbol):\n pybamm.logger.debug(\n \"Calculate boundary gradient ({} and {})\".format(\n left_symbol, right_symbol\n )\n )\n left_domain = left_symbol.domain[0]\n right_domain = right_symbol.domain[0]\n\n left_mesh = self.spatial_methods[left_domain].mesh[left_domain]\n right_mesh = self.spatial_methods[right_domain].mesh[right_domain]\n\n left_symbol_disc = self.process_symbol(left_symbol)\n right_symbol_disc = self.process_symbol(right_symbol)\n\n return self.spatial_methods[left_domain].internal_neumann_condition(\n left_symbol_disc, right_symbol_disc, left_mesh, right_mesh\n )\n\n bc_keys = list(self.bcs.keys())\n\n internal_bcs = {}\n for var in model.boundary_conditions.keys():\n if isinstance(var, pybamm.Concatenation):\n children = var.orphans\n\n first_child = children[0]\n next_child = children[1]\n\n lbc = self.bcs[var][\"left\"]\n rbc = (boundary_gradient(first_child, next_child), \"Neumann\")\n\n if first_child not in bc_keys:\n internal_bcs.update({first_child: {\"left\": lbc, \"right\": rbc}})\n\n for current_child, next_child in zip(children[1:-1], children[2:]):\n lbc = rbc\n rbc = (boundary_gradient(current_child, next_child), \"Neumann\")\n if current_child not in bc_keys:\n internal_bcs.update(\n {current_child: {\"left\": lbc, \"right\": rbc}}\n )\n\n lbc = rbc\n rbc = self.bcs[var][\"right\"]\n if children[-1] not in bc_keys:\n internal_bcs.update({children[-1]: {\"left\": lbc, \"right\": rbc}})\n\n self.bcs.update(internal_bcs)","def apply_boundary_conditions(self):\n E = self.__mesh.get_edge_list()\n\n # Top and bottom wall Dirichlet bcs (boundary_id = 21)\n \n e21_iterator = self.__mesh.edge_iterator(21)\n\n self.edge_center_value[e21_iterator[0]:e21_iterator[1]+1] = 0.0 \n \n # Left Dirichlet bc (boundary_id = 2)\n \n e2_iterator = self.__mesh.edge_iterator(2)\n\n b = np.sin(np.pi*self.y_e[e2_iterator[0]:e2_iterator[1]+1])\n\n self.edge_center_value[e2_iterator[0]:e2_iterator[1]+1] \\\n = b\n \n # Right Neumann bc (Zero flux, boundary_id = 3)\n \n e3_iterator = self.__mesh.edge_iterator(3)\n \n for i in range(e3_iterator[0], e3_iterator[1]+1):\n LC = E[i].get_straddling_cells()\n n = LC.get_global_cell_number() - 1\n self.edge_center_value[i] = self.cell_centroid_value[n]","def increase_right_boundary(self):\n self.R = self.R + 1.0\n self.Ne = self.Ne + 1","def _add_boundaries(self):\n logger.info(\"add_boundaries: start of method\")\n\n import scipy.spatial as sptl\n import scipy.sparse as sprs\n Lx = self._Lx\n Ly = self._Ly\n Lz = self._Lz\n Np = self.num_pores()\n btype = self._btype\n boffset = 0.05\n\n #Translate internal pores to each face of domain\n poffset = np.zeros((7,3))\n poffset[[2,5],0] = [-Lx, Lx]\n poffset[[3,4],1] = [-Ly, Ly]\n poffset[[1,6],2] = [-Lz, Lz]\n pcoords = pcoords0 = self['pore.coords']\n for i in np.r_[1:7]:\n pcoords = np.concatenate((pcoords,pcoords0 + poffset[i,:]),axis=0)\n\n #Use some twisted logic to get bval list of + for boundary and - for periodic faces\n bval = [0, 1, 2, 3, 4, 5, 6]*(np.array([0, btype[2], btype[0], btype[1], btype[1], btype[0], btype[2]])*-2+1)\n ptype = np.zeros((Np,),dtype=int)\n for i in np.r_[1:7]:\n ptype = np.concatenate((ptype,np.ones((Np,),dtype=int)*bval[i]),axis=0)\n\n #pnum contains the internal ID number of the boundary pores (for connecting periodic points)\n pnum = self.pores()\n pnum = np.tile(pnum,7)\n\n Tri = sptl.Delaunay(pcoords)\n adjmat = sprs.lil_matrix((np.shape(pcoords)[0],np.shape(pcoords)[0]),dtype=int)\n for i in np.arange(0,np.shape(Tri.simplices)[0]):\n #Keep only simplices that are fully in real domain\n adjmat[Tri.simplices[i],Tri.simplices[i]] = 1\n adjmat = sprs.triu(adjmat,k=1,format=\"lil\")\n for i in np.arange(0,Np):\n #Add periodic throats to the netowrk (if any)\n tpore2 = pnum[adjmat.rows[i]][ptype[adjmat.rows[i]]<0]\n tpore1 = np.ones_like(tpore2,dtype=int)*i\n conns = self['throat.conns']\n conns = np.concatenate((conns,np.vstack((tpore1,tpore2)).T),axis=0)\n #Add boundary pores and throats to the network\n newporetyps = np.unique(ptype[adjmat.rows[i]][ptype[adjmat.rows[i]]>0])\n newporenums = np.r_[self.num_pores():self.num_pores()+np.size(newporetyps)]\n tpore2 = newporenums\n tpore1 = np.ones_like(tpore2,dtype=int)*i\n conns = np.concatenate((conns,np.vstack((tpore1,tpore2)).T),axis=0)\n self['throat.conns'] = conns\n bcoords = np.zeros((7,3),dtype=float)\n coords = self['pore.coords']\n bcoords[1,:] = [coords[i,0], coords[i,1], 0-Lz*boffset]\n bcoords[2,:] = [0-Lx*boffset, coords[i,1], coords[i,2]]\n bcoords[3,:] = [coords[i,0], -Ly*boffset, coords[i,2]]\n bcoords[4,:] = [coords[i,0], Ly+Ly*boffset, coords[i,2]]\n bcoords[5,:] = [Lx+Lx*boffset, coords[i,1], coords[i,2]]\n bcoords[6,:] = [coords[i,0], coords[i,1], Lz+Lz*boffset]\n newporecoords = bcoords[newporetyps,:]\n coords = np.concatenate((coords,newporecoords),axis=0)\n self['pore.coords'] = coords\n #Reset number of pores and throats (easier than tracking it)\n nums = np.r_[0:np.shape(coords)[0]]\n self['pore.numbering'] = nums\n self['pore.numbering'] = np.ones((nums[-1]+1,),dtype=bool)\n nums = np.r_[0:np.shape(conns)[0]]\n self['throat.numbering'] = nums\n self['throat.numbering'] = np.ones((nums[-1]+1,),dtype=bool)\n logger.debug(\"add_boundaries: end of method\")","def update_real_constants(self, diff_bound):\n self.constants.eq_update_constants(diff_bound)\n self.coefficients = self.constants.get_coefficients()\n return","def SetPRBinConstraint(self, model ) :\n tot = np.multiply(self.wish, self.dispo)\n for val in tot :\n if not val : continue\n if self.bound>0 : model += val <= self.valBound\n elif self.bound<0 : model += val >= self.valBound","def reset_boundaries(self):\n self.L = - np.random.uniform(0.0,1.0)\n self.R = self.L + 1.0\n self.Ne = 0.0\n self.Nc = 0.0","def impose_boundary_conditions(self) -> _ImposeBoundaryConditionsResults:\n\n stiffness = self.get_stiffness_matrix()\n force_vector = self.get_force_vector()\n\n restrained_dofs = self.get_supported_dofs()\n\n for axis in range(2):\n stiffness = np.delete(\n stiffness,\n [dof for dof in restrained_dofs],\n axis=axis,\n )\n\n force_vector = np.delete(\n force_vector,\n [dof for dof in restrained_dofs],\n axis=0,\n )\n\n return _ImposeBoundaryConditionsResults(\n stiffness=stiffness,\n force=force_vector,\n )","def __call__(self, u, dx):\n ru = self.central(u)\n for i,b in self.boundaries:\n if __debug__:\n self.log.debug(\n \"Applying boundary: i = \" + repr(i) + \", b = \" + repr(b)\n )\n ru[i] = b(u, apply_at = i)\n return ru/(dx**self.order)","def update_forces(self):\r\n # update all the functions\r\n self.compute_gravity()\r\n self.compute_tides()\r\n self.compute_centrifugal()\r\n self.compute_coriolis()\r\n\r\n # add together the forces into the summation function\r\n self.forcing.assign(self.ftides+self.gravity +\r\n self.centrifugal+self.coriolis)","def boundary(self):\n answer = self.zero()\n for k, v in self.items():\n for idx, cube in enumerate(k):\n acc_dim = sum((cube_l.dimension for cube_l in k[:idx]))\n for i in range(cube.dimension):\n for epsilon in (0, 1):\n new_cube = cube.face(i, epsilon)\n new_k = k[:idx] + (new_cube,) + k[idx + 1:]\n sign_exp = (acc_dim + i + epsilon) % 2\n answer += answer.create({new_k: v * (-1)**sign_exp})\n return answer","def force ( box, strain, r ):\n\n import numpy as np\n from itertools import product\n import math\n \n # It is assumed that positions are in units where box = 1\n # Forces are calculated in units where sigma = 1 and epsilon = 1\n # Lees-Edwards boundaries, in sliding brick arrangement\n # Flow/gradient/vorticity directions are x/y/z == 0/1/2\n # Uses neighbour lists\n\n n = r.shape[0]\n\n # Set up vectors to half the cells in neighbourhood of 3x3x3 cells in cubic lattice\n # The cells are chosen so that if (d0,d1,d2) appears, then (-d0,-d1,-d2) does not.\n # The last three cells are extra ones, to cope with the sheared system\n d = np.array ( [ [ 0, 0, 0], [ 1, 0, 0], [ 1, 0, 1], [-1, 0, 1], [ 0, 0, 1], # 5 cells with d1=0\n [ 1, 1, -1], [ 1, 1, 0], [ 1, 1, 1], # 3 cells with d0= 1, d1=1\n [ 0, 1, -1], [ 0, 1, 0], [ 0, 1, 1], # 3 cells with d0= 0, d1=1\n [-1, 1, -1], [-1, 1, 0], [-1, 1, 1], # 3 cells with d0=-1, d1=1\n [-2, 1, -1], [-2, 1, 0], [-2, 1, 1] ] ) # 3 cells with d0=-2, d1=1\n\n r[:,0] = r[:,0] - np.rint(r[:,1])*strain # Extra correction in box=1 units\n r = r - np.rint(r) # Ensure all atoms in periodic box\n \n sr2_ovr = 1.77 # Overlap threshold (pot > 100)\n r_cut_box = r_cut / box\n r_cut_box_sq = r_cut_box ** 2\n box_sq = box ** 2\n\n # Initialize\n f = np.zeros_like(r)\n total = PotentialType ( pot=0.0, vir=0.0, pyx=0.0, lap=0.0, ovr=False )\n\n # Calculate cell index triplets\n sc = math.floor(box/r_cut) # Number of cells along box edge\n assert sc >= 3, 'System is too small for cells' # Guard against box being too small\n c = np.floor((r+0.5)*sc).astype(np.int_) # N*3 array of cell indices for all atoms\n assert np.all(c>=0) and np.all(c<sc), 'Index error' # Simplistic \"guard\" against roundoff\n\n shift = math.floor(strain*sc) # Strain measured in cell lengths\n\n if fast:\n \n # Build list of arrays, each array holding positions of atoms in a cell\n # At the same time, define a matching set of force arrays in each cell\n # i and j number the atoms in each cell; we do not refer explicitly to indices in r\n rc, fc = [], [] # Initially empty lists of positions and forces\n for ci in product(range(sc),repeat=3): # Triple loop over cells\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\n rc.append(r[mask,:]) # Copy atom coordinates into array, add to list\n fc.append(np.zeros_like(rc[-1])) # Zero corresponding forces, add to list\n\n for ci1, rci in enumerate(rc): # Loop over i-cells, getting all atoms in each i-cell as an array\n ci = np.unravel_index(ci1,(sc,sc,sc)) # Get i-cell triple-indices\n if rci.size==0: # Handle empty cell\n continue\n\n # Set up correct neighbour cell indices\n if ci[1]==sc-1: # i-cell is in the top layer\n dd = d.copy() # Standard list copied, including extra 3 cells\n dd[5:,0] = d[5:,0] - shift # All those looking up need adjustment in the x direction\n else: # i-cell is not in top layer\n dd = d[:-3,:].copy() # Last three extra cells are not needed; shift is not needed\n \n for dj in dd: # Loop over neighbouring j-cells\n cj = ci + dj # Compute neighbour j-cell triple-indices\n cj1 = np.ravel_multi_index(cj,(sc,sc,sc),mode='wrap') # Convert j-cell to single-index\n rcj = rc[cj1] # Get atoms in j-cell as an array\n if rcj.size==0: # Handle empty cell\n continue\n\n rij = rci[:,np.newaxis,:]-rcj[np.newaxis,:,:] # Separation vectors for all i and j\n rij[:,:,0] = rij[:,:,0] - np.rint(rij[:,:,1])*strain # Extra correction in box=1 units\n rij = rij - np.rint(rij) # PBCs in box=1 units\n rij_sq = np.sum(rij**2,axis=2) # Squared separations\n in_range = rij_sq < r_cut_box_sq # Set flags for within cutoff\n\n if ci1==cj1:\n np.fill_diagonal(in_range,False) # Eliminate i==j when i-cell==j-cell\n np.fill_diagonal(rij_sq,1.0) # Avoid divide-by-zero below\n\n rij_sq = rij_sq * box_sq # Now in sigma=1 units\n rij = rij * box # Now in sigma=1 units\n sr2 = np.where ( in_range, 1.0/rij_sq, 0.0 ) # (sigma/rij)**2, only if in range\n ovr = sr2 > sr2_ovr # Overlap if too close\n sr6 = sr2 ** 3\n sr12 = sr6 ** 2\n pot = sr12 - sr6 # LJ potential (cut but not shifted)\n vir = pot + sr12 # LJ virial\n pot = np.where ( in_range, pot+0.25, 0.0 ) # WCA LJ pair potential (cut-and-shifted)\n lap = ( 22.0*sr12 - 5.0*sr6 ) * sr2 # LJ Laplacian\n fij = vir * sr2 # LJ scalar part of forces\n fij = rij * fij[:,:,np.newaxis] # LJ pair forces\n pyx = rij[:,:,1]*fij[:,:,0] # Off-diagonal element of pressure tensor\n\n if ci1==cj1: # Correct for double-counting ij and ji when i-cell==j-cell\n fij = fij / 2\n total = total + PotentialType ( pot=np.sum(pot)/2, vir=np.sum(vir)/2, \n pyx=np.sum(pyx)/2, lap=np.sum(lap)/2, ovr=np.any(ovr) )\n else:\n total = total + PotentialType ( pot=np.sum(pot), vir=np.sum(vir), \n pyx=np.sum(pyx), lap=np.sum(lap), ovr=np.any(ovr) )\n\n fc[ci1][:,:] = fc[ci1][:,:] + np.sum(fij,axis=1) # Aggregate force on atoms in i-cell\n fc[cj1][:,:] = fc[cj1][:,:] - np.sum(fij,axis=0) # Aggregate force on atoms in j-cell\n\n # Copy forces from list of cell arrays to main force array\n for ci in product(range(sc),repeat=3): # Triple loop over cells\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\n ci1 = np.ravel_multi_index(ci,(sc,sc,sc),mode='wrap') # Single-index\n f[mask,:] = fc[ci1] # Copy atom forces from correct cell\n\n else:\n \n # Build list of arrays, each array holding indices of atoms in a cell\n # ki and kj are atom indices in the r array; i and j number the atoms in each cell\n k_array = np.arange(n) # Atom indices 0..N-1\n kc = [] # Initially empty list of indices\n for ci in product(range(sc),repeat=3): # Triple loop over cells\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\n kc.append(k_array[mask]) # Copy atom indices into array, add to list\n\n for ci1, kci in enumerate(kc): # Loop over i-cells, getting atom indices as an array\n ci = np.unravel_index(ci1,(sc,sc,sc)) # Get i-cell triple-indices\n\n # Set up correct neighbour cell indices\n if ci[1]==sc-1: # i-cell is in the top layer\n dd = d # Standard list copied, including extra 3 cells\n dd[5:,0] = dd[5:,0] - shift # All those looking up need adjustment in the x direction\n else:\n dd = d[:-3,:] # Last three extra cells are not needed; shift is not needed\n\n for dj in dd: # Loop over neighbouring j-cells\n cj = ci + dj # Compute neighbour j-cell triple-indices\n cj1 = np.ravel_multi_index(cj,(sc,sc,sc),mode='wrap') # Convert to single-index\n kcj = kc[cj1] # Get indices of atoms in j-cell as an array\n\n for i, ki in enumerate(kci): # Loop over individual atoms in i-cell\n j0 = i+1 if cj1==ci1 else 0 # Only look upwards if i-cell==j-cell\n if j0 >= kcj.size: # Handles (redundantly) empty j-cell and the case \n continue # where j-cell==i-cell and i is last atom\n\n for kj in kcj[j0:]: # Loop over individual atoms in j-cell\n rij = r[ki,:]-r[kj,:] # Separation vector\n rij[0] = rij[0] - np.rint(rij[1])*strain # Extra correction in box=1 units\n rij = rij - np.rint(rij) # Periodic boundary conditions in box=1 units\n rij_sq = np.sum(rij**2) # Squared separation\n\n if rij_sq < r_cut_box_sq: # Check within cutoff\n rij_sq = rij_sq * box_sq # Now in sigma=1 units\n rij = rij * box # Now in sigma=1 units\n sr2 = 1.0 / rij_sq # (sigma/rij)**2\n ovr = sr2 > sr2_ovr # Overlap if too close\n sr6 = sr2 ** 3\n sr12 = sr6 ** 2\n pot = sr12 - sr6 # LJ potential (cut but not shifted)\n vir = pot + sr12 # LJ virial\n pot = pot + 0.25 # WCA LJ potential (cut-and-shifted)\n lap = ( 22.0*sr12 - 5.0*sr6 ) * sr2 # LJ Laplacian\n fij = rij * vir * sr2 # LJ forces\n pyx = rij[1]*fij[0] # Off-diagonal element of pressure tensor\n total = total + PotentialType ( pot=pot, vir=vir, pyx=pyx, lap=lap, ovr=ovr )\n f[ki,:] = f[ki,:] + fij\n f[kj,:] = f[kj,:] - fij\n\n # Multiply results by numerical factors\n f = f * 24.0 # 24*epsilon\n total.pot = total.pot * 4.0 # 4*epsilon\n total.vir = total.vir * 24.0 / 3.0 # 24*epsilon and divide virial by 3\n total.pyx = total.pyx * 24.0 # 24*epsilon\n total.lap = total.lap * 24.0 * 2.0 # 24*epsilon and factor 2 for ij and ji\n \n return total, f","def _redef_via_predef_eqn(self):\r\n time = self.current_T # + self.d_T\r\n\r\n self.Beta = (self.diff_scale * self.thermal_conductivity) / \\\r\n (self.convect_coeff) \r\n self.Epsilon = self.d_T * self.thermal_conductivity / \\\r\n (self.density * self.heat_capacity)\r\n\r\n # Source term.\r\n def F_func(elem, eta):\r\n x = elem.local_to_global(eta)\r\n F = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n F -= self.Epsilon * self.redef_F_laplacian(x[0], x[1], time)\r\n F += self.redef_dTdt(x[0], x[1], time) * self.d_T\r\n return elem.funcs(eta) * F\r\n\r\n self.vF_vect_vol = et.elems_2_array(self.mesh,\r\n F_func,\r\n self.node_map,\r\n gauss_mult=2) # Use double gp_1D\r\n\r\n # Boundary term.\r\n def f_func(elem, eta):\r\n n = elem.guess_normal_vector_global(eta)\r\n f = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n x = elem.local_to_global(eta)\r\n # Evaluate our boundary term.\r\n f += self.Beta * self.redef_f_norm_grad(x[0], x[1], time, n)\r\n f += self.redef_dTdt(x[0], x[1], time) * self.d_T\r\n return elem.funcs(eta) * f\r\n\r\n self.vf_vect_bound = et.edge_2_array(self.mesh,\r\n \"Boundary\",\r\n f_func,\r\n self.node_map,\r\n gauss_mult=2)","def fix_curvature(self) -> None:\n self.n1.fix = True\n self.n2.fix = True","def calculateExteriorElementBoundaryCoefficients(self):\n #\n #get u and grad(u) at the quadrature points\n #\n for ci in range(self.nc):\n self.u[ci].getValuesGlobalExteriorTrace(self.ebqe[('v',ci)],self.ebqe[('u',ci)])\n if self.ebqe.has_key(('grad(u)',ci)):\n self.u[ci].getGradientValuesGlobalExteriorTrace(self.ebqe[('grad(v)',ci)],self.ebqe[('grad(u)',ci)])\n #\n #get coefficients at the element boundary quadrature points\n #\n self.coefficients.evaluate(t = self.timeIntegration.t, c = self.ebqe)\n #\n #time integration, handled directly in ELLAM formulation\n #\n #ignore numerical flux for now\n #if self.numericalFlux != None:\n # self.numericalFlux.calculateExteriorNumericalFlux(self.inflowFlag,self.q,self.ebqe)\n #flux boundary conditions specified through advective flux\n for ci,fbcObject in self.fluxBoundaryConditionsObjectsDict.iteritems():\n for t,g in fbcObject.advectiveFluxBoundaryConditionsDict.iteritems():\n self.ebqe[('advectiveFlux_bc',ci)][t[0],t[1]] = g(self.ebqe[('x')][t[0],t[1]],self.timeIntegration.t)\n self.ebqe[('advectiveFlux_bc_flag',ci)][t[0],t[1]] = 1","def set_basis(self, maps, methods):\n self.eval_method = methods\n\n def get_grad(maps, shape):\n bfref0 = eval_base(maps.qp_coor, diff=True).swapaxes(1, 2)\n if shape == (1,): # scalar variable\n bfref = bfref0\n elif len(shape) == 1: # vector variable\n vec_shape = nm.array(bfref0.shape + shape)\n vec_shape[1] *= shape[0]\n bfref = nm.zeros(vec_shape)\n for ii in nm.arange(shape[0]):\n slc = slice(ii*bfref0.shape[1], (ii+1)*bfref0.shape[1])\n bfref[:, slc, ii] = bfref0\n else: # higher-order tensors variable\n msg = \"Evaluation of basis has not been implemented \\\n for higher-order tensors yet.\"\n raise NotImplementedError(msg)\n return bfref\n\n def get_val(maps, shape):\n bfref0 = eval_base(maps.qp_coor, diff=False).swapaxes(1, 2)\n\n if self.shape == (1,): # scalar variable\n bfref = bfref0\n elif len(shape) == 1:\n vec_shape = nm.array(bfref0.shape)\n vec_shape[1:3] *= shape[0]\n bfref = nm.zeros(vec_shape)\n for ii in nm.arange(shape[0]):\n slc = slice(ii*bfref0.shape[1], (ii+1)*bfref0.shape[1])\n bfref[:, slc] = bfref0\n else: # higher-order tensors variable\n msg = \"Evaluation of basis has not been implemented \\\n for higher-order tensors yet.\"\n raise NotImplementedError(msg)\n return bfref\n\n eval_base = self.interp.poly_spaces['v'].eval_base\n if self.eval_method[0] == 'val':\n bfref = get_val(maps, self.shape)\n\n elif self.eval_method[0] == 'grad':\n bfref = get_grad(maps, self.shape)\n\n elif self.eval_method[0] == 'div':\n bfref = get_grad(maps, self.shape)\n\n else:\n raise NotImplementedError(\"The method '%s' is not implemented\" \\\n % (self.eval_method))\n\n self.bfref = bfref\n self.n_basis = self.bfref.shape[1]","def set_rhs(self):\n k = self.istore[:, 0]\n ksym = self.stencil.get_symmetric()[k]\n self.rhs[:] = self.feq[k, np.arange(k.size)] + self.feq[ksym, np.arange(k.size)]","def set_rhs(self):\n k = self.istore[:, 0]\n ksym = self.stencil.get_symmetric()[k]\n self.rhs[:] = self.feq[k, np.arange(k.size)] + self.feq[ksym, np.arange(k.size)]","def update_forces(self):\n\n pass","def updateForces(self):\n for atom1 in range(0, self.numAtoms-1):\n for atom2 in range(atom1+1, self.numAtoms):\n self.calculateForce(atom1, atom2)\n \n # Multiply by constants \n for atom in range(0, self.numAtoms):\n self.atoms[atom].fx *= 48*self.e\n self.atoms[atom].fy *= 48*self.e\n self.atoms[atom].fz *= 48*self.e\n self.atoms[atom].potential *= 4*self.e","def term_1(\n omega1, # vorticity-1\n omega2, # vorticity-2\n omega3, # vorticity-3\n enst, # enstrophy\n nu_sgs, # turbulent viscosity\n h = True): # spatial step size\n #---------------------------------------------------------------------#\n # Setting default values #\n #---------------------------------------------------------------------#\n if h is True:\n h = 2.0*np.pi/64.0\n #---------------------------------------------------------------------#\n # Preallocating space #\n #---------------------------------------------------------------------#\n term = np.zeros((64,64,64))\n #---------------------------------------------------------------------#\n # Enstrophy term #\n #---------------------------------------------------------------------#\n term += np.gradient(\\\n np.gradient(enst, h, edge_order=2)[2], h, edge_order=2)[2]\n term += np.gradient(\\\n np.gradient(enst, h, edge_order=2)[1], h, edge_order=2)[1]\n term += np.gradient(\\\n np.gradient(enst, h, edge_order=2)[0], h, edge_order=2)[0]\n #---------------------------------------------------------------------#\n # Dissipation #\n #---------------------------------------------------------------------#\n omega1_grad = np.gradient(omega1, h, edge_order=2)\n omega2_grad = np.gradient(omega2, h, edge_order=2)\n omega3_grad = np.gradient(omega3, h, edge_order=2)\n term -= np.square(omega1_grad[2])\n term -= np.square(omega1_grad[1])\n term -= np.square(omega1_grad[0])\n term -= np.square(omega2_grad[2])\n term -= np.square(omega2_grad[1])\n term -= np.square(omega2_grad[0])\n term -= np.square(omega3_grad[2])\n term -= np.square(omega3_grad[1])\n term -= np.square(omega3_grad[0])\n #---------------------------------------------------------------------#\n # Applying the subgrid stress #\n #---------------------------------------------------------------------#\n term *= nu_sgs\n\n return term","def compute_bounds(self, weights, add_coeff, dual_vars, lower_bounds, upper_bounds, store_primal=False):\n x0_coeff = -weights[0].backward(dual_vars.mus[0])\n x0 = torch.where(x0_coeff >= 0, lower_bounds[0].unsqueeze(1), upper_bounds[0].unsqueeze(1))\n bound = utils.bdot(x0, x0_coeff)\n if store_primal:\n self.bounds_primal = x0\n else:\n del x0\n del x0_coeff\n\n for lay_idx in range(1, len(weights)):\n lbs = lower_bounds[lay_idx].unsqueeze(1).clamp(None, 0)\n ubs = upper_bounds[lay_idx].unsqueeze(1).clamp(0, None)\n neg_bias = ((lbs * ubs) / (ubs - lbs))\n neg_bias.masked_fill_(ubs == lbs, 0) # cover case in which ubs & lbs coincide\n bound += utils.bdot(dual_vars.lambdas[lay_idx - 1].clamp(0, None), neg_bias)\n bound -= utils.bdot(dual_vars.mus[lay_idx - 1], weights[lay_idx - 1].get_bias())\n\n bound += utils.bdot(add_coeff, weights[-1].get_bias())\n return bound","def setup_observation_term(background_data_dict,\n obs_type_vector, obs_data_vector, obs_lat_vector, obs_lon_vector,\n background_type_vector, background_data_vector, background_lat_vector, background_lon_vector,\n direct_obs_operator,\n analysis_increment_vector_symbol,\n increment_data=0.001):\n linearized_obs_operator = sympy.Matrix(\n numpy.ones((len(obs_type_vector), len(background_type_vector))))\n background_derived_obs = sympy.Matrix(\n numpy.ones((len(obs_type_vector), 1)))\n\n for i_obs in range(0, len(obs_data_vector)):\n cur_obs_type = str(obs_type_vector[i_obs])\n cur_obs_lat = float(obs_lat_vector[i_obs])\n cur_obs_lon = float(obs_lon_vector[i_obs])\n\n cur_bk_derived_obs_operator = direct_obs_operator[cur_obs_type]\n required_bk_vars = cur_bk_derived_obs_operator.free_symbols\n \n # 1. calculate h(x):\n bkg_shape = background_data_dict['lat'].shape\n bkg_weight_0 = 0\n bkg_weight_1 = 0\n for ii in range(0, bkg_shape[0]):\n for jj in range(0, bkg_shape[1]):\n cur_bk_lat = background_data_dict['lat'][ii, jj]\n cur_bk_lon = background_data_dict['lon'][ii, jj]\n\n cur_obs_operator_input = {}\n for required_bk_var in required_bk_vars:\n cur_obs_operator_input[str(required_bk_var)] = background_data_dict[str(required_bk_var)][ii, jj]\n\n cur_distance = math.sqrt((cur_obs_lat - cur_bk_lat)**2 + (cur_obs_lon - cur_bk_lon)**2)\n cur_distance_weight_0 = (direct_obs_operator[cur_obs_type].subs(cur_obs_operator_input))/float(cur_distance**2)\n cur_distance_weight_1 = 1.0/float(cur_distance**2)\n bkg_weight_0 = bkg_weight_0 + cur_distance_weight_0\n bkg_weight_1 = bkg_weight_1 + cur_distance_weight_1\n \n background_derived_obs[i_obs, 0] = bkg_weight_0/bkg_weight_1\n final_bkg_weight_1 = bkg_weight_1\n \n # 2. find linearized observation operator\n # n = 0\n for i_bkg in range(0, len(background_type_vector)):\n cur_bk_lat = float(background_lat_vector[i_bkg])\n cur_bk_lon = float(background_lon_vector[i_bkg])\n cur_bk_type = str(background_type_vector[i_bkg])\n \n cur_distance = math.sqrt((cur_obs_lat - cur_bk_lat)**2 + (cur_obs_lon - cur_bk_lon)**2)\n cur_distance_weight_0 = cur_distance ** 2\n distance_term = 1.0/(cur_distance_weight_0 * final_bkg_weight_1)\n \n l = sympy.diff(direct_obs_operator[cur_obs_type], cur_bk_type)\n linearized_obs_operator[i_obs, i_bkg] = distance_term*l.subs(\n {cur_bk_type: float(background_data_vector[i_bkg])})\n \n linearized_obs_operator_with_increments = \\\n linearized_obs_operator*analysis_increment_vector_symbol\n \n # get the innovation:\n innovation = obs_data_vector - background_derived_obs - \\\n linearized_obs_operator_with_increments\n return linearized_obs_operator, innovation, background_derived_obs","def build_constraints_boundaries(self):\n\n # Trapezoidal and Hermite-Simpson methods can't compute\n # defects at the last node contrary to pseudospectral methods\n coll_method = self.options['tr_method'] in [\n 'trapezoidal', 'hermite-simpson']\n n_nodes = self.problem.prm['n_nodes'] - \\\n 1 if coll_method else self.problem.prm['n_nodes']\n\n # Defects lower and upper boundaries\n defects_low = np.zeros(\n self.problem.prm['n_states'] * n_nodes)\n defects_upp = np.zeros(\n self.problem.prm['n_states'] * n_nodes)\n\n # Path lower and upper boundaries\n path_low = np.hstack([self.problem.low_bnd.path]\n * (self.problem.prm['n_nodes']))\n path_upp = np.hstack([self.problem.upp_bnd.path]\n * (self.problem.prm['n_nodes']))\n\n # Events lower and upper boundaries\n event_low = self.problem.low_bnd.event\n event_upp = self.problem.upp_bnd.event\n\n # Assembly of the lower and upper boundaries vectors\n low = np.concatenate((defects_low, path_low, event_low))\n upp = np.concatenate((defects_upp, path_upp, event_upp))\n\n return low, upp","def boundary_conditions(self):\n pass","def relax(self):\n # print(\"putin\", self.level.rhs.reshape(-1)[:])\n # print(\"getout\", self.solver(self.level.rhs.reshape(-1)))\n\n self.level.mid[:] = self.solver(self.level.rhs.reshape(-1)).reshape(self.level.mid.shape)","def update_forces(self):\n element: Cell\n element1: Cell\n element2: Cell\n for element in self.cells:\n element.force = Vector(.0, .0, .0)\n\n tmp_systems = self.cells.copy()\n to_delete = set()\n for element1 in self.cells:\n for element2 in self.cells:\n if element1 == element2:\n continue\n if element2.distance(element1) <= element2.r_max:\n force = find_force(element1, element2)\n element1.force += force\n element2.force += -force\n to_delete.add(element2)\n tmp_systems -= to_delete\n to_delete.clear()","def applyForce(self, F, dT):","def add_cp_le_RBM_terms_alt(K, cons_pot_mesh, lin_geo_mesh):\n num_faces = cons_pot_mesh.get_faces().shape[0]\n x_c = lin_geo_mesh.get_centroid()\n w = lin_geo_mesh.get_w()\n A_m = lin_geo_mesh.get_A_m()\n S_D = lin_geo_mesh.get_surface_area()\n\n for face_num in range(num_faces):\n face_nodes = lin_geo_mesh.get_tri_nodes(face_num)\n face_hs = lin_geo_mesh.get_hs(face_num)\n face_center = lin_geo_mesh.get_tri_center(face_num)\n v_sub_mat = (1. / S_D) * (np.identity(3) * 0.5 * face_hs) # simple integral\n tmp_omega = []\n for m in range(3):\n def make_omega_quad(w, A_m):\n def omega_quad(xi, eta, nodes):\n pos = geo.linear_interp(xi, eta, nodes)\n X = pos - x_c\n return np.cross(w, X)\n return omega_quad\n tmp_omega.append(gq.int_over_tri_lin(\n make_omega_quad(w[m], A_m[m]),\n face_nodes,\n face_hs,\n ))\n for src_num in range(num_faces):\n K[(3 * src_num):(3 * src_num + 3),\n (3 * face_num):(3 * face_num + 3)] += v_sub_mat\n src_center = cons_pot_mesh.get_node(src_num)\n X_0 = src_center - x_c\n tmp_arr = []\n for m in range(3):\n tmp_arr.append(np.outer((1./ A_m[m]) * np.cross(w[m], X_0), tmp_omega[m]))\n tmp_arr = np.array(tmp_arr)\n omega_mat = np.sum(tmp_arr, axis=0)\n K[(3 * src_num):(3 * src_num + 3),\n (3 * face_num):(3 * face_num + 3)] += omega_mat","def do_relax(self):\n raise NotImplementedError","def regularize_if_necessary(self) -> None:\n # As described in [wang2014], all entities and relations are used to compute the regularization term\n # which enforces the defined soft constraints.\n super().regularize_if_necessary(\n self.entity_embeddings.weight,\n self.normal_vector_embeddings.weight,\n self.relation_embeddings.weight,\n )","def test_update_boundary_opt(self):\n self.set_up()\n boundary_opt_new = np.hstack((self.vmecOptimization.boundary_opt,\n self.vmecOptimization.boundary_opt))\n self.assertRaises(ValueError,self.vmecOptimization.update_boundary_opt,\n boundary_opt_new)\n boundary_opt_new = np.copy(self.vmecOptimization.boundary_opt)\n boundary_opt_new[0] = 1\n self.vmecOptimization.update_boundary_opt(boundary_opt_new)\n self.assertEqual(1,self.vmecOptimization.boundary_opt[0])\n self.tear_down()","def calculate_thickness_terms(self):\n\n self.calculate_min_thickness()\n self._calculate_driven_mass()\n self._calculate_resonant_frequency()\n self._calculate_quilting_error()","def incumbent(self):\n return self.boundary_handler.repair(self.mean)","def _set_bounds(b, x, n):\n for j in range(1, n - 1):\n for i in range(1, n - 1):\n x[index_of(i, j, 0, n)] = -x[index_of(i, j, 1, n)] if b == 3 else x[index_of(i, j, 1, n)]\n x[index_of(i, j, 0, n - 1)] = -x[index_of(i, j, 1, n - 2)] if b == 3 else x[index_of(i, j, 1, n - 2)]\n for k in range(1, n - 1):\n for i in range(1, n - 1):\n x[index_of(i, 0, k, n)] = -x[index_of(i, 1, k, n)] if b == 2 else x[index_of(i, 1, k, n)]\n x[index_of(i, n - 1, 0, n - 1)] = -x[index_of(i, n - 2, k, n - 2)] if b == 2 else x[\n index_of(i, n - 2, k, n - 2)]\n for k in range(1, n - 1):\n for j in range(1, n - 1):\n x[index_of(0, j, k, n)] = -x[index_of(1, j, k, n)] if b == 1 else x[index_of(1, j, k, n)]\n x[index_of(n - 1, j, k, n - 1)] = -x[index_of(n - 2, j, k, n)] if b == 1 else x[\n index_of(n - 2, j, k, n)]\n\n x[index_of(0, 0, 0, n)] = 1 / 3 * (x[index_of(1, 0, 0, n)] + x[index_of(0, 1, 0, n)] + x[index_of(0, 0, 1, n)])\n x[index_of(0, n - 1, 0, n)] = 1 / 3 * (\n x[index_of(1, n - 1, 0, n)] + x[index_of(0, n - 2, 0, n)] + x[index_of(0, n - 1, 1, n)])\n x[index_of(0, 0, n - 1, n)] = 1 / 3 * (\n x[index_of(1, 0, n - 1, n)] + x[index_of(0, 1, n - 1, n)] + x[index_of(0, 0, n - 2, n)])\n x[index_of(0, n - 1, n - 1, n)] = 1 / 3 * (\n x[index_of(1, n - 1, n - 1, n)] + x[index_of(0, n - 2, n - 1, n)] + x[index_of(0, n - 1, n - 2, n)])\n x[index_of(n - 1, 0, 0, n)] = 1 / 3 * (\n x[index_of(n - 2, 0, 0, n)] + x[index_of(n - 1, 1, 0, n)] + x[index_of(n - 1, 0, 1, n)])\n x[index_of(n - 1, n - 1, 0, n)] = 1 / 3 * (\n x[index_of(n - 2, n - 1, 0, n)] + x[index_of(n - 1, n - 2, 0, n)] + x[index_of(n - 1, n - 1, 1, n)])\n x[index_of(n - 1, 0, n - 1, n)] = 1 / 3 * (\n x[index_of(n - 2, 0, n - 1, n)] + x[index_of(n - 1, 1, n - 1, n)] + x[index_of(n - 1, 0, n - 2, n)])\n x[index_of(n - 1, n - 1, n - 1, n)] = 1 / 3 * (\n x[index_of(n - 2, n - 1, n - 1, n)] + x[index_of(n - 1, n - 2, n - 1, n)] + x[\n index_of(n - 1, n - 1, n - 2, n)])","def set_initial_condition(self):\n X0 = np.array([0.5, 0.5])\n XB = self.bary\n q0 = 1 + np.exp(-0.5*(np.sum((XB-X0[np.newaxis])**2., axis=1))/0.1**2)\n q1 = np.zeros(q0.shape)\n #import pdb; pdb.set_trace()\n return np.array([q0, q1, q1]).T","def set_boundary(self, t):\n gw_level = self.gwhead[t]\n if np.isfinite(gw_level):\n self.gw.potential = gw_level","def __get_new_restriction_branch_and_bound(self, tableau, var_col, b_value):\n restriction_row = np.zeros((tableau.get_tableau_num_cols())).astype('object')\n restriction_row[var_col] = 1\n restriction_row[tableau.get_tableau_num_cols() - 1] = b_value\n\n for i in xrange(0, len(restriction_row)):\n restriction_row[i] = Fraction(restriction_row[i])\n\n return restriction_row","def compute_ghost_series(self,terms):\n\t\tp=self.p\n\t\tcomp=self.comp\n\t\tf1=self.f1\n\t\tf2=self.f2\n\n\t\tghost_coefs = [[] for i in range(terms+1)]\n\n\n\t\tk=comp;\n\t\tif k==0 or k==1:\n\t\t\tk=k+p-1\n\n\t\t## Precompute the needed dimensions\n\t\tself.f1v = [f1(k)]\n\t\tself.f2v = [f2(k)]\n\t\tk = k + p-1\n\t\twhile self.f1v[len(self.f1v)-1] <= terms+1:\n\t\t\tself.f1v += [f1(k)]\n\t\t\tself.f2v += [f2(k)]\n\t\t\tk = k + p-1\n\t\t\n\t\t## Starting at weight 2, we run through weights in the component,\n\t\t## compute the associated indices, and then record the weights at those\n\t\t## indices with appropriate multiplicities\n\n\t\tk = comp;\n\t\tif k==0 or k==1:\n\t\t\tk=k+p-1\n\t\tn = 0\n\n\t\tinds = range(self.f1v[n]+1,self.f1v[n]+self.f2v[n])\n\t\twhile (len(inds)==0 or inds[0]<=terms+1):\n\t\t\t## This loops adds the weights to the appropriate indices with the appropriate multiplicities\n\t\t\tfor m in range(floor((len(inds)+1)/2)):\n\t\t\t\tif m < floor(len(inds)/2):\n\t\t\t\t\tif inds[m]<=terms:\n\t\t\t\t\t\tghost_coefs[inds[m]] += [(k,m+1)]\n\t\t\t\t\tif (inds[len(inds)-1-m]<=terms):\n\t\t\t\t\t\tghost_coefs[inds[len(inds)-1-m]] += [(k,m+1)]\n\t\t\t\telse:\n\t\t\t\t\tif inds[m]<=terms:\n\t\t\t\t\t\tghost_coefs[inds[m]] += [(k,m+1)]\n\t\t\tk = k + p-1\n\t\t\tn = n + 1\n\t\t\tinds = range(self.f1v[n]+1,self.f1v[n]+self.f2v[n])\n\t\tself.series=ghost_coefs","def normalize_all(self):\n #for i, vector in enumerate(self.real_vectors):\n # self.real_vectors[i] /= np.linalg.norm(vector)\n self.vectors /= np.linalg.norm(self.vectors, axis=1).reshape(-1,1)\n for i, vector in enumerate(self.real_vectors):\n vector.set(self.vectors[i])","def additional_equations(self, k):\n ######################################################################\n # equation for saturated liquid at hot side outlet\n if self.subcooling.val is False:\n o1 = self.outl[0].to_flow()\n self.residual[k] = o1[2] - h_mix_pQ(o1, 0)\n k += 1","def SetPRBinCatConstraint( self, model ) :\n tot = np.dot( self.wish.T, self.dispo )\n for val in tot :\n if not val : continue\n if self.bound>0 : model += val <= self.valBound\n elif self.bound<0 : model += val >= self.valBound","def update(self):\n self._g, self._B = self._constraint_assembler.preallocate_g_and_B(self._no_of_dofs_unconstrained,\n self._dofidxs(),\n self._no_of_constraints_by_object())","def set_freq_relaxation(self):\n self.num_omega=5\n self.omega=np.zeros(self.num_omega)\n iOmH = 3 ; # indexing for the frequencies.\n iOmX = 1 ; #\n # First determine the frequencies omega and J from given inputs.\n self.omega[iOmH] = -1.0*self.gH.gamma*self.B_0*self.time_fact\n self.omega[iOmX] = -1.0*self.gX.gamma*self.B_0*self.time_fact\n self.omega[iOmH-iOmX] = (self.omega[iOmH]-self.omega[iOmX])\n self.omega[iOmH+iOmX] = (self.omega[iOmH]+self.omega[iOmX])","def _merge_boundaries(self):\n optical = self._amalgamated_optical\n if bool(optical):\n optical[\"catagory\"] = OPTICAL * tf.ones_like(\n optical[\"xp\"],\n dtype=tf.int64\n )\n self._optical_count = tf.shape(\n optical[\"xp\"],\n out_type=tf.int64\n )[0]\n else:\n self._optical_count = 0\n \n stop = self._amalgamated_stop\n if bool(stop):\n stop[\"catagory\"] = STOP * tf.ones_like(\n stop[\"xp\"],\n dtype=tf.int64\n )\n self._stop_count = tf.shape(\n stop[\"xp\"],\n out_type=tf.int64\n )[0]\n else:\n self._stop_count = 0\n \n target = self._amalgamated_target\n if bool(target):\n target[\"catagory\"] = TARGET * tf.ones_like(\n target[\"xp\"],\n dtype=tf.int64\n )\n self._target_count = tf.shape(\n target[\"xp\"],\n out_type=tf.int64\n )[0]\n else:\n self._target_count = 0\n \n self._merged = amalgamate(\n [optical, stop, target], \n TRIANGLE_GEO_SIG | {\"catagory\"}\n )","def boundary(self):\n\n answer = self.zero()\n if self.torsion == 2:\n for k in self.keys():\n for idx in range(0, len(k)):\n bdry_summand = k[:idx] + k[idx + 1:]\n if k[idx] in bdry_summand:\n answer += self.create({bdry_summand: 1})\n return answer\n if self.convention == 'Berger-Fresse':\n for k, v in self.items():\n # determining the signs of the summands\n signs = {}\n alternating_sign = 1\n for idx, i in enumerate(k):\n if i in k[idx + 1:]:\n signs[idx] = alternating_sign\n alternating_sign *= (-1)\n elif i in k[:idx]:\n occurs = (pos for pos, j in enumerate(k[:idx]) if i == j)\n signs[idx] = signs[max(occurs)] * (-1)\n else:\n signs[idx] = 0\n # computing the summands\n for idx in range(0, len(k)):\n bdry_summand = k[:idx] + k[idx + 1:]\n if k[idx] in bdry_summand:\n answer += self.create({bdry_summand: signs[idx] * v})\n if self.convention == 'McClure-Smith':\n for k, v in self.items():\n sign = 1\n for i in range(1, max(k) + 1):\n for idx in (idx for idx, j in enumerate(k) if j == i):\n new_k = k[:idx] + k[idx + 1:]\n if k[idx] in new_k:\n answer += answer.create({new_k: v * sign})\n sign *= -1\n sign *= -1\n return answer","def equalize(pair, bias_axis, word_to_vec_map):\n\n ### START CODE HERE ###\n # Step 1: Select word vector representation of \"word\". Use word_to_vec_map. (≈ 2 lines)\n w1, w2 = pair\n e_w1, e_w2 = (word_to_vec_map[w1], word_to_vec_map[w2])\n\n # Step 2: Compute the mean of e_w1 and e_w2 (≈ 1 line)\n mu = (e_w1 + e_w2) / 2\n\n # Step 3: Compute the projections of mu over the bias axis and the orthogonal axis (≈ 2 lines)\n mu_B = np.dot(mu, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\n mu_orth = mu - mu_B\n\n # Step 4: Use equations (7) and (8) to compute e_w1B and e_w2B (≈2 lines)\n e_w1B = np.dot(e_w1, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\n e_w2B = np.dot(e_w2, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\n\n # Step 5: Adjust the Bias part of e_w1B and e_w2B using the formulas (9) and (10) given above (≈2 lines)\n corrected_e_w1B = np.sqrt(np.abs(1 - np.sum(np.dot(mu_orth, mu_orth)))) * (e_w1B - mu_B) / np.sqrt(\n np.sum(np.dot(e_w1 - mu_orth - mu_B, e_w1 - mu_orth - mu_B)))\n corrected_e_w2B = np.sqrt(np.abs(1 - np.sum(np.dot(mu_orth, mu_orth)))) * (e_w2B - mu_B) / np.sqrt(\n np.sum(np.dot(e_w2 - mu_orth - mu_B, e_w2 - mu_orth - mu_B)))\n\n # Step 6: Debias by equalizing e1 and e2 to the sum of their corrected projections (≈2 lines)\n e1 = corrected_e_w1B + mu_orth\n e2 = corrected_e_w2B + mu_orth\n\n ### END CODE HERE ###\n\n return e1, e2","def calculateRightHandSide(self):\n\n #each element triangulation.simplices is a list with the point indices of the triangle\n for ele,triPoints in enumerate(self.triangulation.simplices):\n elementRHS = self.calculateElementRightHandSide(ele)\n\n for index,entry in enumerate(elementRHS):\n self.rightHandSide[triPoints[index]] += entry\n\n #overwrite the values at the prescribed boundaries condition\n for indexValue in self.prescribedValues:\n self.rightHandSide[int(indexValue[0])] = indexValue[1]\n #print(self.rightHandSide)","def add_cp_le_RBM_terms(K, cons_pot_mesh, lin_geo_mesh):\n num_faces = cons_pot_mesh.get_faces().shape[0]\n x_c = lin_geo_mesh.get_centroid()\n w = lin_geo_mesh.get_w()\n A_m = lin_geo_mesh.get_A_m()\n S_D = lin_geo_mesh.get_surface_area()\n\n for face_num in range(num_faces):\n face_nodes = lin_geo_mesh.get_tri_nodes(face_num)\n face_hs = lin_geo_mesh.get_hs(face_num)\n v_sub_mat = (1. / S_D) * (np.identity(3) * 0.5 * face_hs) # simple integral\n def omega_quad(xi, eta, nodes):\n pos = geo.linear_interp(xi, eta, nodes)\n X = pos - x_c\n return np.einsum(\"lrs,s->lr\", geo.LC_3, X)\n tmp_omega = gq.int_over_tri_lin(\n omega_quad,\n face_nodes,\n face_hs,\n )\n tmp_arr = []\n for m in range(3):\n tmp_arr.append((1./ A_m[m]) * np.outer(w[m], np.einsum(\"l,ls\", w[m], tmp_omega)))\n tmp_arr = np.array(tmp_arr)\n tmp_omega_mat = np.sum(tmp_arr, axis=0)\n for src_num in range(num_faces):\n K[(3 * src_num):(3 * src_num + 3),\n (3 * face_num):(3 * face_num + 3)] += v_sub_mat\n #src_center = cons_pot_mesh.get_node(src_num)\n src_center = lin_geo_mesh.get_tri_center(src_num)\n X_0 = src_center - x_c\n omega_mat = np.einsum(\"ijk,js,k->is\", geo.LC_3, tmp_omega_mat, X_0)\n K[(3 * src_num):(3 * src_num + 3),\n (3 * face_num):(3 * face_num + 3)] += omega_mat","def set_bc(self, problem):\n bcs = problem.bcs\n n_bound = cfg.const['N_GHOST_CELLS']\n # Left X-b.c.\n for i in range(0, self.i_min):\n for j in range(self.j_min, self.j_max):\n for k in range(self.k_min, self.k_max): \n if bcs[0] == 't': \n self.U[i][j][k] = self.U[self.i_min][j][k]\n elif bcs[0] == 'w':\n for num in [0, 2, 3, 4]: # 0 -> 3, 1 -> 2, i_min-1 -> i_min, i_min-2 -> i_min+1\n self.U[i][j][k][num] = self.U[self.i_min + (self.i_min - i - 1)][j][k][num]\n for num in [1]:\n self.U[i][j][k][num] = - self.U[self.i_min + (self.i_min - i - 1)][j][k][num]\n else:\n print(\"Errof field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")\n # Right X-b.c.\n for i in range(self.i_max, self.i_max+n_bound):\n for j in range(self.j_min, self.j_max):\n for k in range(self.k_min, self.k_max): \n if bcs[1] == 't':\n self.U[i][j][k] = self.U[self.i_max-1][j][k]\n elif bcs[1] == 'w':\n for num in [0, 2, 3, 4]: # i_max -> i_max-1 , i_max+1-> i_max-2\n self.U[i][j][k][num] = self.U[self.i_max - (i - self.i_max + 1)][j][k][num]\n for num in [1]:\n self.U[i][j][k][num] = - self.U[self.i_max - (i - self.i_max + 1)][j][k][num]\n else:\n print(\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")\n # Left Y-b.c.\n for i in range(0, self.i_max+n_bound):\n for j in range(0, self.j_min):\n for k in range(self.k_min, self.k_max): \n if bcs[2] == 't':\n self.U[i][j][k] = self.U[i][self.j_min][k]\n elif bcs[2] == 'w':\n for num in [0, 1, 3, 4]:\n self.U[i][j][k][num] = self.U[i][self.j_min + (self.j_min - j - 1)][k][num]\n for num in [2]:\n self.U[i][j][k][num] = - self.U[i][self.j_min + (self.j_min - j - 1)][k][num]\n else:\n print(\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")\n # Right Y-b.c.\n for i in range(0, self.i_max+n_bound):\n for j in range(self.j_max, self.j_max+n_bound):\n for k in range(self.k_min, self.k_max): \n if bcs[3] == 't':\n self.U[i][j][k] = self.U[i][self.j_max-1][k]\n elif bcs[3] == 'w':\n for num in [0, 1, 3, 4]:\n self.U[i][j][k][num] = self.U[i][self.j_max - (j - self.j_max + 1)][k][num]\n for num in [2]:\n self.U[i][j][k][num] = -self.U[i][self.j_max - (j - self.j_max + 1)][k][num]\n else:\n print(\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")\n # Left Z-b.c.\n for i in range(0, self.i_max+n_bound):\n for j in range(0, self.j_max+n_bound):\n for k in range(0, self.k_min): \n if bcs[4] == 't':\n self.U[i][j][k] = self.U[i][j][self.k_min]\n elif bcs[4] == 'w':\n for num in [0, 1, 2, 4]:\n self.U[i][j][k][num] = self.U[i][j][self.k_min + (self.k_min - k - 1)][num]\n for num in [3]:\n self.U[i][j][k][num] = - self.U[i][j][self.k_min + (self.k_min - k - 1)][num]\n else:\n print(\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")\n # Right Z-b.c.\n for i in range(0, self.i_max+n_bound):\n for j in range(0, self.j_max+n_bound):\n for k in range(self.k_max, self.k_max+n_bound):\n if bcs[5] == 't':\n self.U[i][j][k] = self.U[i][j][self.k_max-1]\n elif bcs[5] == 'w':\n for num in [0, 1, 2, 4]:\n self.U[i][j][k][num] = self.U[i][j][self.k_max - (k - self.k_max + 1)][num]\n for num in [3]:\n self.U[i][j][k][num] = - self.U[i][j][self.k_max - (k - self.k_max + 1)][num]\n else:\n print(\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\")","def ComputeBasis(self, p_float=..., p_float=..., p_float=..., *args, **kwargs):\n ...","def set_bounds_atom(self,bounds):\n assert bounds.shape == (2,self.Phi.d)\n self.bounds = bounds # data bounds\n self.bounds_atom = bounds.T.tolist()\n for i in range(self.Phi.d): # bounds for the variance in each dimension\n max_variance_this_dimension = (bounds[1][i]-bounds[0][i])**2\n self.bounds_atom.append([self.variance_relative_lowerbound*max_variance_this_dimension,\n self.variance_relative_upperbound*max_variance_this_dimension])","def real_reduce(self, bound, large_constant):\n approximation_matrix = self.generate_approximation_matrix(large_constant)\n LLL_matrix = self.generate_LLL_matrix(approximation_matrix)\n GS_matrix = self.generate_GS_matrix(LLL_matrix) \n minimal_vector_bound = self.calculate_minimal_vector_bound(large_constant, LLL_matrix, GS_matrix)\n S, T = self.calculate_S_and_T(self.coefficients[\"Z_bounds\"])\n print('ST',T**2 + S)\n new_bound = self.real_reduce_new_bound(large_constant, minimal_vector_bound, S, T)\n print('diff_bound',new_bound)\n return new_bound","def additional_equations(self, k):\n ######################################################################\n # equation for saturated gas at hot side outlet\n o1 = self.outl[0].to_flow()\n self.residual[k] = o1[2] - h_mix_pQ(o1, 1)","def test_handling_of_variable_bound_sums_in_merge(free_alg):\n\n dr = free_alg\n p = dr.names\n\n x = IndexedBase('x')\n v = p.v\n i = p.i\n r = p.R\n\n first = dr.sum((i, r), x[i] * v[i])\n\n # First trial, when the ranges are really the same.\n assert dr.simplify(\n first - dr.sum((i, r), x[i] * v[i])\n ) == 0\n\n # This time, they should not be merged.\n assert dr.simplify(\n first - dr.sum((i, r[0, Symbol('n')]), x[i] * v[i])\n ).n_terms == 2","def compute_bound(self, sstats, totals):\n w = self.vocab_len\n t = self.num_time_slices\n\n term_1 = 0\n term_2 = 0\n term_3 = 0\n\n val = 0\n ent = 0\n\n chain_variance = self.chain_variance\n # computing mean, fwd_mean\n self.mean, self.fwd_mean = \\\n (np.array(x) for x in zip(*(self.compute_post_mean(w, self.chain_variance) for w in range(w))))\n self.zeta = self.update_zeta()\n\n val = sum(self.variance[w][0] - self.variance[w][t] for w in range(w)) / 2 * chain_variance\n\n logger.info(\"Computing bound, all times\")\n\n for t in range(1, t + 1):\n term_1 = 0.0\n term_2 = 0.0\n ent = 0.0\n for w in range(w):\n\n m = self.mean[w][t]\n prev_m = self.mean[w][t - 1]\n\n v = self.variance[w][t]\n\n # w_phi_l is only used in Document Influence Model; the values are always zero in this case\n # w_phi_l = sslm.w_phi_l[w][t - 1]\n # exp_i = np.exp(-prev_m)\n # term_1 += (np.power(m - prev_m - (w_phi_l * exp_i), 2) / (2 * chain_variance)) -\n # (v / chain_variance) - np.log(chain_variance)\n\n term_1 += \\\n (np.power(m - prev_m, 2) / (2 * chain_variance)) - (v / chain_variance) - np.log(chain_variance)\n term_2 += sstats[w][t - 1] * m\n ent += np.log(v) / 2 # note the 2pi's cancel with term1 (see doc)\n\n term_3 = -totals[t - 1] * np.log(self.zeta[t - 1])\n val += term_2 + term_3 + ent - term_1\n\n return val","def _construct_compute_fe_terms(self):\n # setup some symbolic variables for theano to deal with\n xi = T.matrix()\n xo = T.matrix()\n _, hi_zmuv = self._construct_zmuv_samples(xi, 1)\n # construct values to output\n nll = self.nlli[-1]\n kld = self.kld_z.flatten() + self.kld_hi_q2p.flatten()\n # compile theano function for a one-sample free-energy estimate\n fe_term_sample = theano.function(inputs=[ xi, xo ], \\\n outputs=[nll, kld], \\\n givens={self.x_in: xi, \\\n self.x_out: xo, \\\n self.hi_zmuv: hi_zmuv}, \\\n updates=self.scan_updates)\n # construct a wrapper function for multi-sample free-energy estimate\n def fe_term_estimator(XI, XO, sample_count):\n # compute a multi-sample estimate of variational free-energy\n nll_sum = np.zeros((XI.shape[0],))\n kld_sum = np.zeros((XI.shape[0],))\n for i in range(sample_count):\n result = fe_term_sample(XI, XO)\n nll_sum += result[0].ravel()\n kld_sum += result[1].ravel()\n mean_nll = nll_sum / float(sample_count)\n mean_kld = kld_sum / float(sample_count)\n return [mean_nll, mean_kld]\n return fe_term_estimator","def removeFixedEffect(self, index=None):\n if self._n_terms==0:\n pass\n if index is None or index==(self._n_terms-1):\n\n self._n_terms-=1\n F = self._F.pop() #= self.F[:-1]\n A = self._A.pop() #= self.A[:-1]\n self._A_identity.pop() #= self.A_identity[:-1]\n REML_term = self._REML_term.pop()# = self.REML_term[:-1]\n self._B.pop()# = self.B[:-1]\n self._n_fixed_effs-=F.shape[1]*A.shape[0]\n if REML_term:\n self._n_fixed_effs_REML-=F.shape[1]*A.shape[0]\n\n pass\n elif index >= self.n_terms:\n raise Exception(\"index exceeds max index of terms\")\n else:\n raise NotImplementedError(\"currently only last term can be removed\")\n pass\n self._rebuild_indicator()\n self.clear_cache('Fstar','Astar','Xstar','Xhat',\n 'Areml','Areml_eigh','Areml_chol','Areml_inv','beta_hat','B_hat',\n 'LRLdiag_Xhat_tens','Areml_grad',\n 'beta_grad','Xstar_beta_grad','Zstar','DLZ')","def addObjFxnTerm(model, A, x, b, wt, n_aux, name, lb=0):\n import gurobipy as gb\n Ax = model.addMVar(n_aux, vtype=gb.GRB.CONTINUOUS, lb=lb, name=name)\n model.addConstr(A @ x == Ax, name=f\"{name}_cons\") # Constrain the Ax auxiliary variable to be equal to query answer\n #return wt * (Ax @ Ax - 2 * b @ Ax) # Quadratic obj_fxn terms for query answers: wt * (Ax - b)^2, constant dropped\n return (Ax @ wt @ Ax - 2 * b @ wt @ Ax) # Quadratic obj_fxn terms for query answers: wt * (Ax - b)^2, constant dropped","def buildWPriorTerm(self):\r\n\r\n # self.w_prior.shape == (minibatch size,)\r\n self.w_prior = 0.5*T.sum(1 + T.log(self.qwgy_var) - self.qwgy_mu**2-self.qwgy_var, axis=1)\r\n\r\n self.w_prior_modif = - T.maximum(self.hyper['treshold_w_prior'], -self.w_prior)","def reset_hessian_and_bias(self):\n # reset_shared_var(self.t_H)\n t = self.QUAD_REG\n if len(t.shape) == 1:\n self.t_H.set_value(np.diag(self.QUAD_REG))\n elif len(t.shape) == 2:\n self.t_H.set_value(self.QUAD_REG)\n else:\n raise ValueError('Invalid quad_reg shape')\n\n reset_shared_var(self.t_B)","def _initialize_bounds(problem, bounds, get_bound, set_bound):\n for constraint in problem.constraints:\n root_expr = constraint.root_expr\n expr_bounds = Interval(constraint.lower_bound, constraint.upper_bound)\n if root_expr not in bounds:\n set_bound(root_expr, expr_bounds)\n else:\n existing_bounds = get_bound(root_expr)\n new_bounds = existing_bounds.intersect(expr_bounds)\n set_bound(root_expr, new_bounds)","def forces(self):\n pass","def epflux_eddyterms():\n pass","def preprocess(self):\n\n if self.x_range == None:\n x_min = min(np.min(self.fx), np.min(self.gx))\n x_max = max(np.max(self.fx), np.max(self.gx))\n self.x_range = [x_min,x_max]\n\n f_inter = interpolate.interp1d(self.fx, self.fy, 'cubic', fill_value = 'extrapolate')\n g_inter = interpolate.interp1d(self.gx, self.gy, 'cubic', fill_value = 'extrapolate')\n fgx_new = np.linspace(self.x_range[0], self.x_range[1], self.N)\n fy_new = f_inter(fgx_new)\n gy_new = g_inter(fgx_new)\n\n self.fx, self.fy = fgx_new, fy_new\n self.gx, self.gy = fgx_new, gy_new","def calc(self):\n\n # the following if query ensures that volume- and interaction-terms\n # are only calculated if tau > 0.\n # (to avoid nan-values from invalid function-evaluations)\n\n if self.V.tau.shape == (1,):\n Isurf = self.surface()\n # differentiation for non-existing canopy, as otherwise NAN values\n if self.V.tau > 0.:\n Ivol = self.volume()\n if self.int_Q is True:\n Iint = self.interaction()\n else:\n Iint = np.array([0.])\n else:\n Ivol = np.array([0.])\n Iint = np.array([0.])\n else:\n # calculate surface-term (valid for any tau-value)\n Isurf = self.surface()\n\n # store initial parameter-values\n old_t_0 = self.t_0\n old_p_0 = self.p_0\n old_t_ex = self.t_ex\n old_p_ex = self.p_ex\n\n old_tau = self.V._get_tau()\n old_omega = self.V._get_omega()\n old_NN = self.SRF._get_NormBRDF()\n\n # set mask for tau > 0.\n mask = old_tau > 0.\n valid_index = np.where(mask)\n inval_index = np.where(~mask)\n\n # set parameter-values to valid values for calculation\n self.t_0 = old_t_0[valid_index[0]]\n self.p_0 = old_p_0[valid_index[0]]\n self.t_ex = old_t_ex[valid_index[0]]\n self.p_ex = old_p_ex[valid_index[0]]\n\n # squeezing the arrays is necessary since the setter-function for\n # tau, omega and NormBRDF automatically adds an axis to the arrays!\n self.V.tau = np.squeeze(old_tau[valid_index[0]])\n if np.array(self.V.omega).size != 1:\n self.V.omega = np.squeeze(old_omega[valid_index[0]])\n if np.array(self.SRF.NormBRDF).size != 1:\n self.SRF.NormBRDF = np.squeeze(old_NN[valid_index[0]])\n\n # calculate volume and interaction term where tau-values are valid\n _Ivol = self.volume()\n if self.int_Q is True:\n _Iint = self.interaction()\n else:\n _Iint = np.full_like(self.t_0, 0.)\n\n # reset parameter values to old values\n self.t_0 = old_t_0\n self.p_0 = old_p_0\n self.t_ex = old_t_ex\n self.p_ex = old_p_ex\n\n # squeezing the arrays is necessary since the setter-function for\n # tau, omega and NormBRDF automatically add an axis to the arrays!\n self.V.tau = np.squeeze(old_tau)\n self.V.omega = np.squeeze(old_omega)\n self.SRF.NormBRDF = np.squeeze(old_NN)\n\n # combine calculated volume-contributions for valid tau-values\n # with zero-arrays for invalid tau-values\n Ivol = np.ones_like(self.t_0)\n Ivol[valid_index[0]] = _Ivol\n Ivol[inval_index[0]] = np.ones_like(Ivol[inval_index[0]]) * 0.\n\n # combine calculated interaction-contributions for valid tau-values\n # with zero-arrays for invalid tau-values\n if self.int_Q is True:\n Iint = np.ones_like(self.t_0)\n Iint[valid_index[0]] = _Iint\n Iint[inval_index[0]] = np.ones_like(Iint[inval_index[0]]) * 0.\n else:\n Iint = np.full_like(self.t_0, 0.)\n\n return Isurf + Ivol + Iint, Isurf, Ivol, Iint","def _redef_sp1_vars(self):\r\n\r\n if len(self.fq_list) == 0:\r\n no_rad = True\r\n lst_tmp = np.matrix(np.reshape(self.lst_tmp, \r\n (self.lst_tmp.size, 1)))\r\n else: no_rad = False\r\n # The practically constants...\r\n # Big Epsilon:\r\n if self.cond == True:\r\n self.Epsilon = self.d_T * self.thermal_conductivity\r\n else:\r\n self.Epsilon = (self.diff_scale ** 2) / \\\r\n (3.0 * self.absorb_coeffs[self.rad] ** 2)\r\n # Beta:\r\n if self.cond == True:\r\n self.Beta = (self.diff_scale * self.thermal_conductivity) / \\\r\n (self.convect_coeff)\r\n else:\r\n self.Beta = (1.0 + 3.0 * self.r2) * (2.0 * self.diff_scale) / \\\r\n ((1.0 - 2.0 * self.r1) * (\r\n 3.0 * self.absorb_coeffs[self.rad]))\r\n\r\n # The feild solutions at the last timestep.\r\n # The integral vF:\r\n if self.cond == True:\r\n # The horrifically complicated F:\r\n def F_func_cond(elem, eta):\r\n F = 0.0\r\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n F += Tn\r\n for k in range(0, len(self.fq_list)):\r\n vk = self.fq_list[k]\r\n try:\r\n vk_m = self.fq_list[k - 1]\r\n except:\r\n vk_m = self.v0_frequency\r\n absorbtion = self.absorb_coeffs[k]\r\n phi = elem.eval_elem(self.node_map, self.lst_rad[k],\r\n [eta])[0]\r\n inter1 = phi - 4.0 * sconst.pi * \\\r\n self.B_int_function(Tn, self.refr_idx_vol,\r\n vk, vk_m)\r\n inter2 = absorbtion * self.d_T / (self.diff_scale ** 2)\r\n F += inter2 * inter1\r\n return elem.funcs(eta) * F\r\n if not no_rad:\r\n # We're integrating something non-linear for SP1\r\n self.vF_vect_vol = et.elems_2_array(self.mesh,\r\n F_func_cond,\r\n self.node_map)\r\n else:\r\n # Or something easier if we're only looking at heat.\r\n self.vF_vect_vol = np.array(self.uv_vol * lst_tmp).reshape(-1)\r\n else:\r\n def F_func_radiative(elem, eta):\r\n T = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n vk = self.fq_list[self.rad]\r\n try:\r\n vk_minus = self.fq_list[self.rad - 1]\r\n except:\r\n vk_minus = self.v0_frequency\r\n n = self.refr_idx_vol\r\n F = 4.0 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\r\n return elem.funcs(eta) * F\r\n\r\n self.vF_vect_vol = et.elems_2_array(self.mesh,\r\n F_func_radiative,\r\n self.node_map)\r\n # The path integral vf:\r\n if self.cond == True:\r\n def f_func_cond(elem, eta):\r\n Tb = self.background_temperature\r\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n n = self.refr_idx_background\r\n vk = self.v0_frequency\r\n vk_minus = 0\r\n Bb0 = self.B_int_function(Tb, n, vk, vk_minus)\r\n Bn0 = self.B_int_function(Tn, n, vk, vk_minus)\r\n B_coeff = (self.alpha * sconst.pi) / self.convect_coeff\r\n f = Tb + B_coeff * (Bb0 - Bn0)\r\n return elem.funcs(eta) * f\r\n if not no_rad:\r\n self.vf_vect_bound = et.edge_2_array(self.mesh,\r\n \"Boundary\",\r\n f_func_cond,\r\n self.node_map)\r\n else:\r\n try:\r\n self.vf_vect_bound = self.cache_tb_integral_array\r\n except AttributeError:\r\n def elem_functor(elem, eta): return elem.funcs(eta)\r\n self.cache_tb_integral_array = et.edge_2_array(self.mesh,\r\n \"Boundary\",\r\n elem_functor,\r\n self.node_map)\r\n self.cache_tb_integral_array *= self.background_temperature\r\n self.vf_vect_bound = self.cache_tb_integral_array\r\n \r\n else:\r\n # Radiation f = 4*pi*B^{(k)}(T_b, n_g)\r\n def f_func_radiative(elem, eta):\r\n T = self.background_temperature\r\n vk = self.fq_list[self.rad]\r\n try:\r\n vk_minus = self.fq_list[self.rad - 1]\r\n except:\r\n vk_minus = self.v0_frequency\r\n n = self.refr_idx_vol\r\n f = 4 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\r\n return elem.funcs(eta) * f\r\n\r\n self.vf_vect_bound = et.edge_2_array(self.mesh,\r\n \"Boundary\",\r\n f_func_radiative,\r\n self.node_map)\r\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\r\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\r\n assert (self.vf_vect_bound.shape[0] == \\\r\n self.vF_vect_vol.shape[0])","def eventually(self, t1, t2):\n new_robustness = lambda s, t : max([ self.robustness(s,k) for k in range(t+t1, t+t2+1)])\n\n new_formula = STLFormula(new_robustness)\n\n return new_formula","def _manage_infinity_bounds(problem, _bounds, get_bound, set_bound):\n for variable in problem.variables:\n expr_bounds = get_bound(variable)\n lower_bound = expr_bounds.lower_bound\n upper_bound = expr_bounds.upper_bound\n\n if is_inf(lower_bound):\n new_lower_bound = None\n else:\n new_lower_bound = lower_bound\n\n if is_inf(upper_bound):\n new_upper_bound = None\n else:\n new_upper_bound = upper_bound\n\n set_bound(variable, Interval(new_lower_bound, new_upper_bound))","def calculateExteriorElementBoundaryQuadrature(self):\n #\n #get physical locations of element boundary quadrature points\n #\n #assume all components live on the same mesh\n self.u[0].femSpace.elementMaps.getValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\n self.ebqe['x'])\n #\n #get metric tensor and unit normals\n #\n if self.movingDomain:\n if self.tLast_mesh != None:\n self.ebqe['xt'][:]=self.ebqe['x']\n self.ebqe['xt']-=self.ebqe['x_last']\n alpha = 1.0/(self.t_mesh - self.tLast_mesh)\n self.ebqe['xt']*=alpha\n else:\n self.ebqe['xt'][:]=0.0\n self.ebqe['x_last'][:]=self.ebqe['x']\n self.u[0].femSpace.elementMaps.getJacobianValuesGlobalExteriorTrace_movingDomain(self.elementBoundaryQuadraturePoints,\n self.ebqe['xt'],\n self.ebqe['inverse(J)'],\n self.ebqe['g'],\n self.ebqe['sqrt(det(g))'],\n self.ebqe['n'])\n else:\n self.u[0].femSpace.elementMaps.getJacobianValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\n self.ebqe['inverse(J)'],\n self.ebqe['g'],\n self.ebqe['sqrt(det(g))'],\n self.ebqe['n'])\n #now map the physical points back to the reference element\n #assume all components live on same mesh\n self.u[0].femSpace.elementMaps.getInverseValuesGlobalExteriorTrace(self.ebqe['inverse(J)'],self.ebqe['x'],self.ebqe['hat(x)'])\n #\n #since the points on the reference boundary may be reordered on many right element boundaries, we\n #have to use an array of reference boundary points on all element boundaries\n #first copy the left reference element boundary quadrature points from the reference element boundary\n self.testSpace[0].getBasisValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\n self.ebqe[('w',0)])\n cfemIntegrals.calculateWeightedShapeGlobalExteriorTrace(self.mesh.exteriorElementBoundariesArray,\n self.mesh.elementBoundaryElementsArray,\n self.mesh.elementBoundaryLocalElementBoundariesArray,\n self.elementBoundaryQuadratureWeights[('f',0)],\n self.ebqe['sqrt(det(g))'],\n self.ebqe[('w',0)],\n self.ebqe[('w*dS_f',0)])\n self.u[0].femSpace.getBasisGradientValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\n self.ebqe['inverse(J)'],\n self.ebqe[('grad(v)',0)])\n #setup flux boundary conditions\n self.fluxBoundaryConditionsObjectsDict = dict([(cj,FluxBoundaryConditions(self.mesh,\n self.nElementBoundaryQuadraturePoints_elementBoundary,\n self.ebqe[('x')],\n self.advectiveFluxBoundaryConditionsSetterDict[cj],\n self.diffusiveFluxBoundaryConditionsSetterDictDict[cj]))\n for cj in self.advectiveFluxBoundaryConditionsSetterDict.keys()])\n self.ebqe['dS'] = numpy.zeros((self.mesh.nExteriorElementBoundaries_global,self.nElementBoundaryQuadraturePoints_elementBoundary),'d')\n cfemIntegrals.calculateIntegrationWeights(self.ebqe['sqrt(det(g))'],\n self.elementBoundaryQuadratureWeights[('u',0)],\n self.ebqe['dS'])\n for ci in range(self.nc): self.ebqe[('dS',ci)] = self.ebqe['dS']\n #\n self.ellamDiscretization.calculateExteriorElementBoundaryQuadrature(self.ebqe)\n #\n self.coefficients.initializeGlobalExteriorElementBoundaryQuadrature(self.timeIntegration.t,self.ebqe)","def R_term(\n enst, # enstrophy field\n omega1, # vorticity-1 component\n omega2, # vorticity-2 component\n omega3, # vorticity-3 component\n s11, # strain rate-11 component\n s12, # strain rate-12 component\n s13, # strain rate-13 component\n s22, # strain rate-22 component\n s23, # strain rate-23 component\n s33, # strain rate-33 component\n diff = False): # differentiation flag\n #---------------------------------------------------------------------#\n # Defining domain variables #\n #---------------------------------------------------------------------#\n pi = np.pi # pi\n dx = (2.0*pi)/64.0 # spatial step\n nu = 0.000185 # default viscosity\n #---------------------------------------------------------------------#\n # Spectral differentiation variables #\n #---------------------------------------------------------------------#\n dim = 64\n kspec = np.fft.fftfreq(dim) * dim\n Kfield = np.array(np.meshgrid(kspec, kspec, kspec, indexing='ij'))\n #---------------------------------------------------------------------#\n # Spectral differentiation variables #\n #---------------------------------------------------------------------#\n term1 = np.zeros((dim, dim, dim))\n term2 = np.zeros((dim, dim, dim))\n term3 = np.zeros((dim, dim, dim))\n #---------------------------------------------------------------------#\n # Numerator (numpy gradient tool) #\n #---------------------------------------------------------------------#\n if diff is not False:\n term1 = np.gradient(enst,dx, edge_order=2)[0]\n term2 = np.gradient(enst,dx, edge_order=2)[1]\n term3 = np.gradient(enst,dx, edge_order=2)[2]\n #---------------------------------------------------------------------#\n # Numerator (spectral differentiation) #\n #---------------------------------------------------------------------#\n else:\n term1 = 0.5*np.fft.ifftn(1j*Kfield[0]*np.fft.fftn(enst) +\\\n 1j*Kfield[0]*np.fft.fftn(enst)).real\n term2 = 0.5*np.fft.ifftn(1j*Kfield[1]*np.fft.fftn(enst) +\\\n 1j*Kfield[1]*np.fft.fftn(enst)).real\n term3 = 0.5*np.fft.ifftn(1j*Kfield[2]*np.fft.fftn(enst) +\\\n 1j*Kfield[2]*np.fft.fftn(enst)).real\n #---------------------------------------------------------------------#\n # Numerator #\n #---------------------------------------------------------------------#\n num = nu*(term1**2.0+ term2**2.0 + term3**2.0)\n #---------------------------------------------------------------------#\n # Denominator #\n #---------------------------------------------------------------------#\n den = omega1*s11*omega1 + omega1*s12*omega2 + omega1*s13*omega3 +\\\n omega2*s12*omega1 + omega2*s22*omega2 + omega2*s23*omega3+\\\n omega3*s13*omega1 + omega3*s23*omega2 + omega3*s33*omega3\n #---------------------------------------------------------------------#\n # R calculation #\n #---------------------------------------------------------------------#\n R = num/den\n\n return R","def update_boundary(self):\n\n cell = self._fire_boundary.dequeue()\n neighbors = self.four_neighbors(cell[0], cell[1])\n #neighbors = self.eight_neighbors(cell[0], cell[1])\n for neighbor in neighbors:\n if self.is_empty(neighbor[0], neighbor[1]):\n self.set_full(neighbor[0], neighbor[1])\n self._fire_boundary.enqueue(neighbor)\n\n # Check class invariant after update\n assert self.boundary_invariant()","def do(self, variables, values):\n intervened = LinearGaussianBN()\n sym_values = [Symbol(val) if isinstance(val, str) else val for val in values]\n var_to_value = dict(zip(variables, sym_values))\n for variable in self.variables:\n if variable not in variables:\n new_parents = []\n new_weights = [self._weights[variable][0]]\n for indx, p in enumerate(self.parents(variable)):\n w = self._weights[variable][indx + 1]\n if p not in variables:\n new_parents.append(p)\n new_weights.append(w)\n else:\n new_weights[0] += w * var_to_value[p]\n\n intervened.add_var(variable, new_parents, new_weights)\n\n return intervened","def SetPRCatConstraint(self, model ) :\n tot = np.multiply(self.wish, self.dispo)\n for line in tot :\n for val in line :\n if not val : continue\n if self.bound>0 : model += val <= self.valBound\n elif self.bound<0 : model += val >= self.valBound","def terms(self, terms):\n\n self._terms = terms","def set_weight(term, irrelevant):\n if term in irrelevant:\n return (0.2 * max([x/sum(indtf_features[term]) for x in indtf_features[term]]))\n elif isinstance(term, tuple):\n return len(term)\n else:\n return 1","def _compute_forces(self):\n # get new coeffs\n self._get_coeffs()\n\n # instead of writing many time\n awa = self.awa / 180.0 * np.pi\n\n # lift and drag\n self.lift = 0.5 * self.rho * self.aws ** 2 * self.area * self.cl\n self.drag = 0.5 * self.rho * self.aws ** 2 * self.area * self.cd + self._get_Rw(awa)\n\n # project into yacht coordinate system\n self.Fx = self.lift * np.sin(awa) - self.drag * np.cos(awa)\n self.Fy = self.lift * np.cos(awa) + self.drag * np.sin(awa)\n\n # heeling moment\n self.Mx = self.Fy * self._vce() * np.cos(self.phi / 180.0 * np.pi)\n\n # side-force is horizontal component of Fh\n self.Fy *= np.cos(np.deg2rad(self.phi))","def initialize_constants(self):\n # maximum pheromone value\n self.PH_MAX = np.float_( len(self.variables) / (1.0 - self.PH_REDUCE_FACTOR))\n # minimum pheromone value\n self.PH_MIN = np.float_(self.PH_MAX / (2*len(self.variables)) )","def _solve_freq_rb(self, d, v, a, force, freqw, freqw2, incrb, unc):\n if self.rbsize and incrb:\n rb = self.rb\n if self.m is not None:\n if unc:\n a_rb = self.invm[self._rb] * force[rb]\n else:\n a_rb = la.lu_solve(self.imrb, force[rb], check_finite=False)\n else:\n a_rb = force[rb]\n if \"d\" in incrb or \"v\" in incrb:\n pvnz = freqw != 0\n if \"v\" in incrb:\n v[rb, pvnz] = (-1j / freqw[pvnz]) * a_rb[:, pvnz]\n if \"d\" in incrb:\n d[rb, pvnz] = (-1.0 / freqw2[pvnz]) * a_rb[:, pvnz]\n if \"a\" in incrb:\n a[rb] = a_rb","def test_basic_handling_range_with_variable_bounds(spark_ctx):\n\n dr = Drudge(spark_ctx)\n\n j1, j2 = symbols('j1 j2')\n m1, m2 = symbols('m1, m2')\n j_max = symbols('j_max')\n j = Range('j', 0, j_max)\n m = Range('m')\n dr.set_dumms(j, [j1, j2])\n dr.set_dumms(m, [m1, m2])\n\n v = Vec('v')\n x = IndexedBase('x')\n tensor = dr.sum((j2, j), (m2, m[0, j2]), x[j2, m2] * v[j2, m2])\n\n reset = tensor.reset_dumms()\n assert reset.n_terms == 1\n term = reset.local_terms[0]\n assert len(term.sums) == 2\n if term.sums[0][1].label == 'j':\n j_sum, m_sum = term.sums\n else:\n m_sum, j_sum = term.sums\n assert j_sum[0] == j1\n assert j_sum[1].args == j.args\n assert m_sum[0] == m1\n assert m_sum[1].label == 'm'\n assert m_sum[1].lower == 0\n assert m_sum[1].upper == j1 # Important!\n assert term.amp == x[j1, m1]\n assert term.vecs == (v[j1, m1],)\n\n # Test that functions can be mapped to the bounds.\n repled = reset.map2scalars(\n lambda x: x.xreplace({j_max: 10}), skip_ranges=False\n )\n assert repled.n_terms == 1\n term = repled.local_terms[0]\n checked = False\n for _, i in term.sums:\n if i.label == 'j':\n assert i.lower == 0\n assert i.upper == 10\n checked = True\n continue\n assert checked","def force ( r, e ):\n from math import isclose\n\n # Parameters of the Gay-Berne potential \n # \n # The key parameters are \n # mu, nu ................ the exponents \n # kappa and kappa' ....... the anisotropies \n # kappa is the ratio of intermolecular separations \n # sigma_e / sigma_s i.e. end-to-end / side-by-side \n # kappa' is the ratio of well depths \n # epsilon_s / epsilon_e i.e. side-by-side / end-to-end \n # The derived parameters are chi and chi' \n # chi = (kappa**2 - 1) / (kappa**2+1) \n # chi' = (z - 1) / (z + 1)\n # where z = (kappa') ** ( 1 / mu ) \n # \n # For convenience kappa' is spelt xappa, chi' is spelt xhi\n # We choose units such that sigma_s = 1.0 and epsilon_0 = 1.0\n # Two of the following three varieties should be commented out\n\n # Original Gay-Berne-deMiguel potential [J. Chem. Phys, 74, 3316; Mol. Phys. 74, 405 (1991)]\n mu, nu, kappa, xappa = 2, 1, 3.0, 5.0\n\n # # Luckhurst-Phippen potential [Liq. Cryst., 8, 451 (1990)]\n # mu, nu, kappa, xappa = 1, 2, 3.0, 5.0\n\n # # Berardi-Zannoni potential [J. Chem. Soc. Faraday Trans., 89, 4069 (1993)]\n # mu, nu, kappa, xappa = 1, 3, 3.0, 5.0\n\n # Derived parameters\n chi = (kappa**2 - 1.0) / (kappa**2+1.0)\n xhi = (xappa**(1.0/mu) - 1.0) / (xappa**(1.0/mu) + 1.0)\n\n # Cutoff distance; normally we would use a larger value\n r_cut = 4.0\n \n assert r.shape == (n,3), 'Incorrect shape of r'\n assert e.shape == (n,3), 'Incorrect shape of e'\n\n # Notation to match appendix\n i = 0\n j = 1\n\n ei = e[i,:]\n ej = e[j,:]\n assert isclose(np.sum(ei**2),1.0), 'Non-unit vector {} {} {}'.format(*ei)\n assert isclose(np.sum(ej**2),1.0), 'Non-unit vector {} {} {}'.format(*ej)\n\n rij = r[i,:] - r[j,:]\n rij_mag = np.sqrt( np.sum(rij**2) ) # Magnitude of separation vector\n sij = rij / rij_mag # Unit vector\n ci = np.dot( ei, sij )\n cj = np.dot( ej, sij )\n cij = np.dot( ei, ej )\n cp = ci + cj\n cm = ci - cj\n\n # Sigma formula\n cpchi = cp/(1.0+chi*cij)\n cmchi = cm/(1.0-chi*cij)\n sigma = 1.0/np.sqrt(1.0-0.5*chi*(cp*cpchi+cm*cmchi))\n\n # Epsilon formula\n eps1 = 1.0/np.sqrt(1.0-(chi*cij)**2) # Depends on chi, not xhi\n cpxhi = cp/(1.0+xhi*cij)\n cmxhi = cm/(1.0-xhi*cij)\n eps2 = 1.0-0.5*xhi*(cp*cpxhi+cm*cmxhi) # Depends on xhi\n epsilon = (eps1**nu) * (eps2**mu)\n\n # Potential at rij\n rho = rij_mag - sigma + 1.0\n rho6 = 1.0 / rho**6\n rho12 = rho6**2\n rhoterm = 4.0*(rho12 - rho6) # Needed for forces and torques\n drhoterm = -24.0 * (2.0 * rho12 - rho6) / rho # Needed for forces and torques\n pot = epsilon*rhoterm\n\n # Potential at r_cut\n rho = r_cut - sigma + 1.0\n rho6 = 1.0 / rho**6\n rho12 = rho6**2\n cutterm = 4.0*(rho12 - rho6) # Needed for cutoff forces and torques\n dcutterm = -24.0 * (2.0 * rho12 - rho6) / rho # Needed for cutoff forces and torques\n pot = pot - epsilon * cutterm\n\n # Derivatives of sigma\n prefac = 0.5*chi*sigma**3\n dsig_dci = prefac*(cpchi+cmchi)\n dsig_dcj = prefac*(cpchi-cmchi)\n prefac = prefac*(0.5*chi)\n dsig_dcij = -prefac*(cpchi**2-cmchi**2)\n\n # Derivatives of epsilon\n prefac = -mu*xhi*(eps1**nu)*eps2**(mu-1)\n deps_dci = prefac*(cpxhi+cmxhi)\n deps_dcj = prefac*(cpxhi-cmxhi)\n prefac = prefac*(0.5*xhi)\n deps_dcij = -prefac*(cpxhi**2-cmxhi**2) # From derivative of eps2\n deps_dcij = deps_dcij + nu*(chi**2)*(eps1**(nu+2))*(eps2**mu)*cij # From derivative of eps1\n\n # Derivatives of potential\n dpot_drij = epsilon * drhoterm\n dpot_dci = rhoterm * deps_dci - epsilon * drhoterm * dsig_dci\n dpot_dcj = rhoterm * deps_dcj - epsilon * drhoterm * dsig_dcj\n dpot_dcij = rhoterm * deps_dcij - epsilon * drhoterm * dsig_dcij\n\n # Standard formula for forces and torque gradients\n fij = -dpot_drij*sij - dpot_dci*(ei-ci*sij)/rij_mag - dpot_dcj*(ej-cj*sij)/rij_mag\n gi = dpot_dci*sij + dpot_dcij*ej\n gj = dpot_dcj*sij + dpot_dcij*ei\n\n # Derivatives of potential at cutoff\n dpot_drij = epsilon * dcutterm\n dpot_dci = cutterm * deps_dci - epsilon * dcutterm * dsig_dci\n dpot_dcj = cutterm * deps_dcj - epsilon * dcutterm * dsig_dcj\n dpot_dcij = cutterm * deps_dcij - epsilon * dcutterm * dsig_dcij\n\n # Standard formula for forces and torque gradients (without dpot_drij term)\n fij = fij + dpot_dci*(ei-ci*sij)/rij_mag + dpot_dcj*(ej-cj*sij)/rij_mag\n gi = gi - ( dpot_dci*sij + dpot_dcij*ej ) \n gj = gj - ( dpot_dcj*sij + dpot_dcij*ei ) \n\n # Final forces and torques\n f = np.empty_like(r)\n t = np.empty_like(r)\n f[i,:] = fij\n f[j,:] = -fij\n t[i,:] = -np.cross(ei,gi)\n t[j,:] = -np.cross(ej,gj)\n\n return pot, f, t","def wang(G, term1, term2):\n if term1 not in G or term2 not in G:\n return 0\n sa = s_values(G, term1)\n sb = s_values(G, term2)\n sva = sum(sa.values())\n svb = sum(sb.values())\n common = set(sa.keys()) & set(sb.keys())\n cv = sum(sa[c] + sb[c] for c in common)\n return round(cv / (sva + svb), 3)","def calculate_boundaries(self, latmesh=False, mask=None, lat_mask=None,\n adot=None, U_mask=None, mark_divide=False):\n s = \"::: calculating boundaries :::\"\n print_text(s, cls=self)\n\n if lat_mask == None and mark_divide:\n s = \">>> IF PARAMETER <mark_divide> OF calculate_boundaries() IS \" + \\\n \"TRUE, PARAMETER <lat_mask> MUST BE AN EXPRESSION FOR THE LATERAL\" + \\\n \" BOUNDARIES <<<\"\n print_text(s, 'red', 1)\n sys.exit(1)\n \n # this function contains markers which may be applied to facets of the mesh\n self.ff = FacetFunction('size_t', self.mesh)\n self.ff_acc = FacetFunction('size_t', self.mesh)\n self.cf = CellFunction('size_t', self.mesh)\n dofmap = self.Q.dofmap()\n\n S = self.S\n B = self.B\n \n # default to all grounded ice :\n if mask == None:\n mask = Expression('1.0', element=self.Q.ufl_element())\n \n # default to all positive accumulation :\n if adot == None:\n adot = Expression('1.0', element=self.Q.ufl_element())\n \n # default to U observations everywhere :\n if U_mask == None:\n U_mask = Expression('1.0', element=self.Q.ufl_element())\n\n self.init_adot(adot)\n self.init_mask(mask)\n self.init_U_mask(U_mask)\n\n if mark_divide:\n s = \" - marking the interior facets for incomplete meshes -\"\n print_text(s, cls=self)\n self.init_lat_mask(lat_mask)\n\n self.S.set_allow_extrapolation(True)\n self.B.set_allow_extrapolation(True)\n self.mask.set_allow_extrapolation(True)\n self.adot.set_allow_extrapolation(True)\n self.U_mask.set_allow_extrapolation(True)\n self.lat_mask.set_allow_extrapolation(True)\n \n tol = 1e-6\n \n s = \" - marking boundaries - \"\n print_text(s, cls=self)\n\n if latmesh:\n s = \" - using a lateral surface mesh - \"\n print_text(s, cls=self)\n \n class GAMMA_S_GND(SubDomain):\n def inside(self, x, on_boundary):\n return mask(x[0], x[1], x[2]) <= 1.0 and on_boundary\n gamma_s_gnd = GAMMA_S_GND()\n\n class GAMMA_S_FLT(SubDomain):\n def inside(self, x, on_boundary):\n return mask(x[0], x[1], x[2]) > 1.0 and on_boundary\n gamma_s_flt = GAMMA_S_FLT()\n\n class GAMMA_U_GND(SubDomain):\n def inside(self, x, on_boundary):\n return abs(x[2] - S(x[0], x[1], x[2])) < tol \\\n and mask(x[0], x[1], x[2]) <= 1.0 \\\n and U_mask(x[0], x[1], x[2]) <= 0.0 and on_boundary\n gamma_u_gnd = GAMMA_U_GND()\n\n class GAMMA_U_FLT(SubDomain):\n def inside(self, x, on_boundary):\n return abs(x[2] - S(x[0], x[1], x[2])) < tol \\\n and mask(x[0], x[1], x[2]) > 1.0 \\\n and U_mask(x[0], x[1], x[2]) <= 0.0 and on_boundary\n gamma_u_flt = GAMMA_U_FLT()\n\n class GAMMA_B_GND(SubDomain):\n def inside(self, x, on_boundary):\n return abs(x[2] - B(x[0], x[1], x[2])) < tol \\\n and mask(x[0], x[1], x[2]) <= 1.0 and on_boundary\n gamma_b_gnd = GAMMA_B_GND()\n\n class GAMMA_B_FLT(SubDomain):\n def inside(self, x, on_boundary):\n return abs(x[2] - B(x[0], x[1], x[2])) < tol \\\n and mask(x[0], x[1], x[2]) > 1.0 and on_boundary\n gamma_b_flt = GAMMA_B_FLT()\n\n class GAMMA_L_OVR(SubDomain):\n def inside(self, x, on_boundary):\n return x[2] > -10 and x[2] < S(x[0], x[1], x[2]) - tol and on_boundary\n gamma_l_ovr = GAMMA_L_OVR()\n\n class GAMMA_L_UDR(SubDomain):\n def inside(self, x, on_boundary):\n return x[2] < 10 and x[2] < S(x[0], x[1], x[2]) - tol and on_boundary\n gamma_l_udr = GAMMA_L_UDR()\n\n class GAMMA_L_TRM(SubDomain):\n def inside(self, x, on_boundary):\n return lat_mask(x[0], x[1], x[2]) <= 0.0\n gamma_l_trm = GAMMA_L_TRM()\n\n gamma_s_flt.mark(self.ff, self.GAMMA_S_FLT)\n gamma_s_gnd.mark(self.ff, self.GAMMA_S_GND)\n gamma_l_ovr.mark(self.ff, self.GAMMA_L_OVR)\n gamma_l_udr.mark(self.ff, self.GAMMA_L_UDR)\n gamma_b_flt.mark(self.ff, self.GAMMA_B_FLT)\n gamma_b_gnd.mark(self.ff, self.GAMMA_B_GND)\n #gamma_u_flt.mark(self.ff, self.GAMMA_U_FLT)\n #gamma_u_gnd.mark(self.ff, self.GAMMA_U_GND)\n #if mark_divide: \n # gamma_l_trm.mark(self.cf, 1)\n \n else :\n s = \" - not using a lateral surface mesh - \"\n print_text(s, cls=self)\n\n class GAMMA_GND(SubDomain):\n def inside(self, x, on_boundary):\n return mask(x[0], x[1], x[2]) <= 1.0\n gamma_gnd = GAMMA_GND()\n\n class GAMMA_FLT(SubDomain):\n def inside(self, x, on_boundary):\n return mask(x[0], x[1], x[2]) > 1.0\n gamma_flt = GAMMA_FLT()\n\n class GAMMA_L_OVR(SubDomain):\n def inside(self, x, on_boundary):\n return x[2] > -10 and on_boundary\n gamma_l_ovr = GAMMA_L_OVR()\n\n class GAMMA_L_UDR(SubDomain):\n def inside(self, x, on_boundary):\n return x[2] < 10 and on_boundary\n gamma_l_udr = GAMMA_L_UDR()\n\n gamma_flt.mark(self.cf, 1)\n gamma_gnd.mark(self.cf, 0)\n gamma_l_ovr.mark(self.ff, self.GAMMA_L_OVR)\n gamma_l_udr.mark(self.ff, self.GAMMA_L_UDR)\n \n # mark the divide if desired : \n if mark_divide:\n class GAMMA_L_DVD(SubDomain):\n def inside(self, x, on_boundary):\n return lat_mask(x[0], x[1], x[2]) <= 0.0 and on_boundary\n gamma_l_dvd = GAMMA_L_DVD()\n gamma_l_dvd.mark(self.ff, self.GAMMA_L_DVD)\n \n s = \" - done - \"\n print_text(s, cls=self)\n \n #s = \" - iterating through %i cells - \" % self.num_cells\n #print_text(s, cls=self)\n #for c in cells(self.mesh):\n # x_m = c.midpoint().x()\n # y_m = c.midpoint().y()\n # z_m = c.midpoint().z()\n # mask_xy = mask(x_m, y_m, z_m)\n\n # if mask_xy > 1:\n # self.cf[c] = 1\n # else:\n # self.cf[c] = 0\n\n #s = \" - done - \"\n #print_text(s, cls=self)\n\n self.ds = Measure('ds')[self.ff]\n self.dx = Measure('dx')#[self.cf]\n \n self.dx_g = self.dx(0) # internal above grounded\n self.dx_f = self.dx(1) # internal above floating\n self.dBed_g = self.ds(3) # grounded bed\n self.dBed_f = self.ds(5) # floating bed\n self.dBed = self.ds(3) + self.ds(5) # bed\n self.dSrf_gu = self.ds(8) # grounded with U observations\n self.dSrf_fu = self.ds(9) # floating with U observations\n self.dSrf_u = self.ds(8) + self.ds(9) # surface with U observations\n self.dSrf_g = self.ds(2) + self.ds(8) # surface of grounded ice\n self.dSrf_f = self.ds(6) + self.ds(9) # surface of floating ice\n self.dSrf = self.ds(6) + self.ds(2) \\\n + self.ds(8) + self.ds(9) # surface\n self.dLat_d = self.ds(7) # lateral divide\n self.dLat_to = self.ds(4) # lateral terminus overwater\n self.dLat_tu = self.ds(10) # lateral terminus underwater\n self.dLat_t = self.ds(4) + self.ds(10) # lateral terminus\n self.dLat = self.ds(4) + self.ds(7) \\\n + self.ds(10) # lateral","def chgvarbound(self,j_,lower_,finite_,value_): # 3\n res = self.__obj.chgvarbound(j_,lower_,finite_,value_)\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)","def add_bcs(self, RHS, bc_left, cff0 ,cff1, cff2):\n RHS[0] += cff0 * self.c[0]/(2*self.dx)*bc_left\n RHS[0] += cff1 * self.c[0]/(2*self.dx)*self.bcs[1]\n RHS[0] += cff2 * self.c[0]/(2*self.dx)*self.bcs[2]","def _para_boosting(self, H):\n # print '----------------primal-dual boost-------------------'\n H = np.hstack((H, -H))\n # H_ft = np.asfortranarray((H.copy()))\n (n, p) = H.shape\n self.c = np.log(n*p)\n nu = int(n * self.ratio)\n\n if self.max_iter < 50:\n delta = 1\n else:\n delta = 40\n d = np.ones(n) / n\n d_bar = np.ones(n) / n\n a_bar = np.ones(p) / p\n a = np.ones(p) / p\n h_a = np.sum(H, axis=1) / p\n h_a_bar = h_a.copy()\n # a_bar = a\n # a_tilde = np.ones(p) / p\n h_a_tilde = h_a.copy()\n # d_tilde = np.zeros(p)\n theta = 1\n sig = 1\n tau = 1\n t = 0\n logscale = 0\n for t in range(self.max_iter):\n d = prox_mapping(h_a_tilde, d, tau, 2)\n if self.has_dcap:\n d2 = proj_cap_ent(d, 1.0 / nu)\n # d_new = d_new/d_new.sum()\n if np.abs(d.sum() - d2.sum()) > 0.0001:\n print 'error'\n d = d2\n d_tilde = d\n dtH = np.dot(d_tilde, H)\n # dtH = np.dot(H.T, d_tilde)\n a_new = prox_mapping(-dtH, a, sig, 2)\n h_a_new = np.dot(H, a_new)\n # a_tilde = a_new + theta * (a_new - a)\n h_a_tilde = (1+theta) * h_a_new - theta * h_a\n a = a_new\n h_a = h_a_new\n d_bar *= t / (t + 1.0)\n d_bar += 1.0 / (t + 1) * d\n a_bar *= t / (t + 1.0)\n a_bar += 1.0 / (t + 1) * a\n # h_a_bar = np.dot(H, a_bar)\n h_a_bar = t / (t + 1.0) * h_a_bar + 1.0/(t+1) * h_a\n if int(np.log(t+1)) == logscale:\n logscale += 1\n self.iter_num.append(t)\n if self.has_dcap:\n min_margin = ksmallest2(h_a_bar, nu)\n self.primal_obj.append(-np.mean(min_margin))\n else:\n self.primal_obj.append(- np.min(h_a_bar))\n self.margin.append(-self.primal_obj[-1])\n self.dual_obj.append(-np.max(np.dot(d_bar, H)))\n self.gap.append(self.primal_obj[-1] - self.dual_obj[-1])\n self.err_tr.append(np.mean(h_a_bar < 0))\n # if t % 100 == 0:\n # print 'iter ' + str(t) + ' ' + str(self.gap[-1])\n if self.gap[-1] < self.epsi:\n break\n self.alpha = a_bar[:p / 2] - a_bar[p / 2:]\n self.d = d_bar\n print \" pd-boosting(python): max iter#%d: , actual iter#%d\" % (self.max_iter, t)","def convergence_check(self):\n air = self.air_alias.val\n flue_gas = self.fuel_alias.val + '_fg'\n fuel = self.fuel_alias.val\n\n for c in self.outl:\n if not c.fluid.val_set[air]:\n if c.fluid.val[air] > 0.95:\n c.fluid.val[air] = 0.95\n if c.fluid.val[air] < 0.5:\n c.fluid.val[air] = 0.5\n\n if not c.fluid.val_set[flue_gas]:\n if c.fluid.val[flue_gas] > 0.5:\n c.fluid.val[flue_gas] = 0.5\n if c.fluid.val[flue_gas] < 0.05:\n c.fluid.val[flue_gas] = 0.05\n\n if not c.fluid.val_set[fuel]:\n if c.fluid.val[fuel] > 0:\n c.fluid.val[fuel] = 0\n\n c.target.propagate_fluid_to_target(c, c.target)\n\n for i in self.inl:\n if i.m.val_SI < 0 and not i.m.val_set:\n i.m.val_SI = 0.01\n\n for c in self.outl:\n if c.m.val_SI < 0 and not c.m.val_set:\n c.m.val_SI = 10\n c.target.propagate_fluid_to_target(c, c.target)\n\n if self.lamb.val < 1 and not self.lamb.is_set:\n self.lamb.val = 2","def _add_unconformity_below(self, feature):\n for f in self.features:\n if f.type == 'series' and feature.feature.name != f.name:\n f.add_region(lambda pos: ~feature.evaluate(pos))\n # for f in reversed(self.features):\n # if f.type == 'unconformity':\n # feature.add_region(lambda pos: f.evaluate(pos))\n # break\n # feature.add_region(lambda pos: ~uc.evaluate(pos))","def add_cp_qe_RBM_terms(K, cons_pot_mesh, quad_geo_mesh):\n num_faces = cons_pot_mesh.get_faces().shape[0]\n x_c = quad_geo_mesh.get_centroid()\n w = quad_geo_mesh.get_w()\n A_m = quad_geo_mesh.get_A_m()\n S_D = quad_geo_mesh.get_surface_area()\n\n for face_num in range(num_faces):\n face_nodes = quad_geo_mesh.get_tri_nodes(face_num)\n face_hs = quad_geo_mesh.get_hs(face_num)\n def v_quad(_xi, _eta, _nodes):\n return np.identity(3)\n v_sub_mat = (1. / S_D) * gq.int_over_tri_quad(v_quad, face_nodes, face_hs)\n def omega_quad(xi, eta, nodes):\n pos = geo.quadratic_interp(xi, eta, nodes)\n X = pos - x_c\n return np.einsum(\"lrs,s->lr\", geo.LC_3, X)\n tmp_omega = gq.int_over_tri_quad(\n omega_quad,\n face_nodes,\n face_hs,\n )\n tmp_arr = []\n for m in range(3):\n tmp_arr.append((1./ A_m[m]) * np.outer(w[m], np.einsum(\"l,ls\", w[m], tmp_omega)))\n tmp_arr = np.array(tmp_arr)\n tmp_omega_mat = np.sum(tmp_arr, axis=0)\n for src_num in range(num_faces):\n K[(3 * src_num):(3 * src_num + 3),\n (3 * face_num):(3 * face_num + 3)] += v_sub_mat\n src_center = cons_pot_mesh.get_node(src_num)\n X_0 = src_center - x_c\n omega_mat = np.einsum(\"ijk,js,k->is\", geo.LC_3, tmp_omega_mat, X_0)\n K[(3 * src_num):(3 * src_num + 3),\n (3 * face_num):(3 * face_num + 3)] += omega_mat","def restrict(self):\n\n cg = self.grid.coarse_like(2)\n\n c_edge_coeffs = EdgeCoeffs(cg, None, empty=True)\n\n c_eta_x = cg.scratch_array()\n c_eta_y = cg.scratch_array()\n\n fg = self.grid\n\n c_eta_x[cg.ilo:cg.ihi+2,cg.jlo:cg.jhi+1] = \\\n 0.5*(self.x[fg.ilo:fg.ihi+2:2,fg.jlo :fg.jhi+1:2] +\n self.x[fg.ilo:fg.ihi+2:2,fg.jlo+1:fg.jhi+1:2])\n\n # redo the normalization\n c_edge_coeffs.x = c_eta_x*fg.dx**2/cg.dx**2\n\n c_eta_y[cg.ilo:cg.ihi+1,cg.jlo:cg.jhi+2] = \\\n 0.5*(self.y[fg.ilo :fg.ihi+1:2,fg.jlo:fg.jhi+2:2] +\n self.y[fg.ilo+1:fg.ihi+1:2,fg.jlo:fg.jhi+2:2])\n\n c_edge_coeffs.y = c_eta_y*fg.dy**2/cg.dy**2\n\n return c_edge_coeffs","def _update_conformers(self, cutoff=0.002):\n logger.debug(\"Updating conformers based on occupancy\")\n\n # Check that all arrays match dimensions.\n assert len(self._occupancies) == len(self._coor_set) == len(self._bs)\n\n # Filter all arrays & lists based on self._occupancies\n # NB: _coor_set and _bs are lists (not arrays). We must compress, not slice.\n filterarray = self._occupancies >= cutoff\n self._occupancies = self._occupancies[filterarray]\n self._coor_set = list(itertools.compress(self._coor_set, filterarray))\n self._bs = list(itertools.compress(self._bs, filterarray))\n\n logger.debug(f\"Remaining valid conformations: {len(self._coor_set)}\")","def normalize_bounds(self, bounds):\n scaled_bounds = []\n scalings = []\n intercepts = []\n \n non_fixed_params = []\n \n print(self.device)\n \n for name, domain in self.bounds.items():\n # Get any fixed parmeters\n if type(domain) == int or type(domain) == float:\n # Take note\n self.fixed_parameters.append(name)\n\n # Free parameters\n elif type(domain) == tuple:\n # Bookkeeping\n self.free_parameters.append(name)\n\n # Get scaling\n lower_bound = min(domain)\n upper_bound = max(domain)\n scale = upper_bound - lower_bound\n\n # Transform to [0, 1] domain\n #scaled_bound = {'name': name, 'type': 'continuous', 'domain': (0., 1.)} #torch.adjustment required\n non_fixed_params.append(name)\n \n # Store\n #scaled_bounds.append(scaled_bound)\n scalings.append(scale)\n intercepts.append(lower_bound)\n else:\n raise ValueError(\"Domain bounds not understood\")\n \n n_hyperparams = len(non_fixed_params)\n \n scaled_bounds = cat([zeros(1,n_hyperparams, device = self.device), \n ones(1, n_hyperparams, device = self.device)], 0)\n return scaled_bounds, tensor(scalings, device = self.device, requires_grad = False), tensor(intercepts, device = self.device, requires_grad = False) #torch.adjustment required","def always(self, t1, t2):\n new_robustness = lambda s, t : min([ self.robustness(s,k) for k in range(t+t1, t+t2+1)])\n\n new_formula = STLFormula(new_robustness)\n\n return new_formula","def _bowl_params(self):\n self.vars['bowl_strength'] = self.bowl.strength + \\\n self.vars['beta_min_offset']\n self.vars['q_init'] = self.vars['bowl_strength']\n if self.vars['bowl_strength'] <= self.vars['beta_min_offset']:\n print(\n f\"Bowl overflow -- Set to the minimum value : {self.vars['beta_min_offset']}\")\n # raise ValueError(\"Bowl overflow... strength lower than set tolerance. Modify the tolerance or fix the bug!\")\n self.vars['bowl_strength'] = self.vars['beta_min_offset']\n if self.vars['bowl_strength'] > self.vars['q_max']:\n self.vars['bowl_strength'] = self.vars['q_max']\n\n self.vars['zeta_bowl'] = self.toNeural(self.bowl.center)\n print(f\"Value for Q set to {self.vars['bowl_strength']}\")","def relax(self,n=1):\n # print(\"putin\", self.level.rhs.reshape(-1)[:])\n # print(\"getout\", self.solver(self.level.rhs.reshape(-1)))\n for i in range(n):\n self.level.mid[:] += (self.solver(self.level.rhs.reshape(-1)) -\n self.solver(self.stencil.eval_convolve(\n self.level.evaluable_view(self.stencil)).reshape(-1))).reshape(self.level.mid.shape)","def compute_bounds(self):\n # Note: linear_constraints object has been been populated at this stage\n L_zero_var = []\n \n for constraint in self._linear_constraints.L_linear_constraints:\n lhs_string = constraint[0]\n rhs_string = constraint[1]\n if float(rhs_string)==0:\n #print \"rhs=0: forcing the variables to zero\"\n L_vars = re.split(r'[+-]',lhs_string)\n \n for var in L_vars:\n modform_var = var.strip()\n \n # forcing all the variables in this constraint to be zero\n self._linear_constraints.modform_space.D_PuLP_variables[modform_var] = pulp.LpVariable(modform_var, lowBound=0, upBound=0)\n #print \"var forced to zero: \", modform_var\n L_zero_var.append(modform_var)\n else: #if float(rhs)==0\n continue\n \n if len(L_zero_var)>0:\n print \"\\n####### Variables forced to zero (rhs = 0) ##########\"\n print \"variables forced to zero: \", set(L_zero_var)\n \n feasible_lc = flc.FeasibleLinearConstraints(self._linear_constraints)\n \n feasible_lc.get_feasible_linear_constraints()\n \n feasible_linear_constraints = feasible_lc.feasible_linear_constraints\n \n lp_solver = lps.LinearProgrammingSolver(feasible_linear_constraints)\n \n D_lower_bounds = {}; D_upper_bounds = {}\n \n for v in [self._linear_constraints.modform_space.D_PuLP_variables[k] for k in sorted(self._linear_constraints.modform_space.D_PuLP_variables.keys(), key=gbfunc.natural_keys)]:\n \n if str(v) in L_zero_var:\n D_lower_bounds[str(v)] = '0'\n D_upper_bounds[str(v)] = '0'\n continue\n #end if str(v) in L_zero_var\n \n objective_function_PuLP = v\n \n list_values_minimize = lp_solver.linear_programming_solver(objective_function_PuLP, pulp.LpMinimize)\n D_lower_bounds[str(v)] = \"%.3f\"%round(pulp.value(v),3)\n \n list_values_maximize = lp_solver.linear_programming_solver(objective_function_PuLP, pulp.LpMaximize)\n D_upper_bounds[str(v)] = \"%.3f\"%round(pulp.value(v),3)\n\n #end for v in ..\n\n return((D_lower_bounds, D_upper_bounds))"],"string":"[\n \"def calculateElementBoundaryCoefficients(self):\\n pass\",\n \"def update(self):\\n\\n terms_toRemove = []\\n\\n for termIndex, [term_constantFactor, term_unknowns_attributeAddresses] in enumerate(self.LHS):\\n\\n # Check if coefficient is 0 - then no need to process any of the unknowns since term will be 0 anyways\\n if term_constantFactor == 0:\\n terms_toRemove.append(termIndex)\\n continue # continue to next term, no need to resolve the unknowns of this term since the product will be 0 anyways\\n\\n # Check if any unknowns became known\\n unknowns_toRemove = []\\n for unknown_attributeAddress in term_unknowns_attributeAddresses:\\n attribute = getattr_fromAddress(*unknown_attributeAddress)\\n if isNumeric(attribute):\\n # object.attribute which had previously been identified as unknown now has a value, add it to the constant factor product and remove from the unknowns\\n self.LHS[termIndex][0] *= attribute # multiply it with the constant factor product\\n unknowns_toRemove.append([termIndex, unknown_attributeAddress])\\n for termIndex, unknown_attributeAddress in unknowns_toRemove: # remove unknowns which have become known in the end\\n # removing in the end not to tamper with the iteration of the above loop\\n self.LHS[termIndex][1].remove(unknown_attributeAddress)\\n\\n # Move constants to RHS\\n if self.LHS[termIndex][1] == []:\\n # if term has no unknowns, it is a constant, move to RHS\\n self.RHS -= self.LHS[termIndex][0]\\n self.LHS.pop(termIndex)\\n\\n for termIndex in reversed(terms_toRemove): # reversed - otherwise would tamper with indices of items identified for removal\\n self.LHS.pop(termIndex)\\n\\n self._gatherUnknowns()\",\n \"def boundary_conditions(self):\\n ce = 2 * self.dy * self.g * self.mu * self.m_u / self.kb\\n self.e[0, :] = (4 * self.e[1, :] - self.e[2, :]) / (\\n ce / self.T[0, :] + 3\\n )\\n self.rho[0, :] = (\\n self.e[0, :]\\n * (self.Y - 1)\\n * self.mu\\n * self.m_u\\n / (self.kb * self.T[0, :])\\n )\\n self.u[0, :] = (4 * self.u[1, :] - self.u[2, :]) / 3\\n self.w[0, :] = 0\\n\\n self.e[-1, :] = (4 * self.e[-2, :] - self.e[-3, :]) / (\\n 3 - ce / self.T[-1, :]\\n )\\n self.rho[-1, :] = (\\n self.e[-1, :]\\n * (self.Y - 1)\\n * self.mu\\n * self.m_u\\n / (self.kb * self.T[-1, :])\\n )\\n self.u[-1, :] = (4 * self.u[-2, :] - self.u[-3, :]) / 3\\n self.w[-1, :] = 0\",\n \"def set_internal_boundary_conditions(self, model):\\n\\n def boundary_gradient(left_symbol, right_symbol):\\n pybamm.logger.debug(\\n \\\"Calculate boundary gradient ({} and {})\\\".format(\\n left_symbol, right_symbol\\n )\\n )\\n left_domain = left_symbol.domain[0]\\n right_domain = right_symbol.domain[0]\\n\\n left_mesh = self.spatial_methods[left_domain].mesh[left_domain]\\n right_mesh = self.spatial_methods[right_domain].mesh[right_domain]\\n\\n left_symbol_disc = self.process_symbol(left_symbol)\\n right_symbol_disc = self.process_symbol(right_symbol)\\n\\n return self.spatial_methods[left_domain].internal_neumann_condition(\\n left_symbol_disc, right_symbol_disc, left_mesh, right_mesh\\n )\\n\\n bc_keys = list(self.bcs.keys())\\n\\n internal_bcs = {}\\n for var in model.boundary_conditions.keys():\\n if isinstance(var, pybamm.Concatenation):\\n children = var.orphans\\n\\n first_child = children[0]\\n next_child = children[1]\\n\\n lbc = self.bcs[var][\\\"left\\\"]\\n rbc = (boundary_gradient(first_child, next_child), \\\"Neumann\\\")\\n\\n if first_child not in bc_keys:\\n internal_bcs.update({first_child: {\\\"left\\\": lbc, \\\"right\\\": rbc}})\\n\\n for current_child, next_child in zip(children[1:-1], children[2:]):\\n lbc = rbc\\n rbc = (boundary_gradient(current_child, next_child), \\\"Neumann\\\")\\n if current_child not in bc_keys:\\n internal_bcs.update(\\n {current_child: {\\\"left\\\": lbc, \\\"right\\\": rbc}}\\n )\\n\\n lbc = rbc\\n rbc = self.bcs[var][\\\"right\\\"]\\n if children[-1] not in bc_keys:\\n internal_bcs.update({children[-1]: {\\\"left\\\": lbc, \\\"right\\\": rbc}})\\n\\n self.bcs.update(internal_bcs)\",\n \"def apply_boundary_conditions(self):\\n E = self.__mesh.get_edge_list()\\n\\n # Top and bottom wall Dirichlet bcs (boundary_id = 21)\\n \\n e21_iterator = self.__mesh.edge_iterator(21)\\n\\n self.edge_center_value[e21_iterator[0]:e21_iterator[1]+1] = 0.0 \\n \\n # Left Dirichlet bc (boundary_id = 2)\\n \\n e2_iterator = self.__mesh.edge_iterator(2)\\n\\n b = np.sin(np.pi*self.y_e[e2_iterator[0]:e2_iterator[1]+1])\\n\\n self.edge_center_value[e2_iterator[0]:e2_iterator[1]+1] \\\\\\n = b\\n \\n # Right Neumann bc (Zero flux, boundary_id = 3)\\n \\n e3_iterator = self.__mesh.edge_iterator(3)\\n \\n for i in range(e3_iterator[0], e3_iterator[1]+1):\\n LC = E[i].get_straddling_cells()\\n n = LC.get_global_cell_number() - 1\\n self.edge_center_value[i] = self.cell_centroid_value[n]\",\n \"def increase_right_boundary(self):\\n self.R = self.R + 1.0\\n self.Ne = self.Ne + 1\",\n \"def _add_boundaries(self):\\n logger.info(\\\"add_boundaries: start of method\\\")\\n\\n import scipy.spatial as sptl\\n import scipy.sparse as sprs\\n Lx = self._Lx\\n Ly = self._Ly\\n Lz = self._Lz\\n Np = self.num_pores()\\n btype = self._btype\\n boffset = 0.05\\n\\n #Translate internal pores to each face of domain\\n poffset = np.zeros((7,3))\\n poffset[[2,5],0] = [-Lx, Lx]\\n poffset[[3,4],1] = [-Ly, Ly]\\n poffset[[1,6],2] = [-Lz, Lz]\\n pcoords = pcoords0 = self['pore.coords']\\n for i in np.r_[1:7]:\\n pcoords = np.concatenate((pcoords,pcoords0 + poffset[i,:]),axis=0)\\n\\n #Use some twisted logic to get bval list of + for boundary and - for periodic faces\\n bval = [0, 1, 2, 3, 4, 5, 6]*(np.array([0, btype[2], btype[0], btype[1], btype[1], btype[0], btype[2]])*-2+1)\\n ptype = np.zeros((Np,),dtype=int)\\n for i in np.r_[1:7]:\\n ptype = np.concatenate((ptype,np.ones((Np,),dtype=int)*bval[i]),axis=0)\\n\\n #pnum contains the internal ID number of the boundary pores (for connecting periodic points)\\n pnum = self.pores()\\n pnum = np.tile(pnum,7)\\n\\n Tri = sptl.Delaunay(pcoords)\\n adjmat = sprs.lil_matrix((np.shape(pcoords)[0],np.shape(pcoords)[0]),dtype=int)\\n for i in np.arange(0,np.shape(Tri.simplices)[0]):\\n #Keep only simplices that are fully in real domain\\n adjmat[Tri.simplices[i],Tri.simplices[i]] = 1\\n adjmat = sprs.triu(adjmat,k=1,format=\\\"lil\\\")\\n for i in np.arange(0,Np):\\n #Add periodic throats to the netowrk (if any)\\n tpore2 = pnum[adjmat.rows[i]][ptype[adjmat.rows[i]]<0]\\n tpore1 = np.ones_like(tpore2,dtype=int)*i\\n conns = self['throat.conns']\\n conns = np.concatenate((conns,np.vstack((tpore1,tpore2)).T),axis=0)\\n #Add boundary pores and throats to the network\\n newporetyps = np.unique(ptype[adjmat.rows[i]][ptype[adjmat.rows[i]]>0])\\n newporenums = np.r_[self.num_pores():self.num_pores()+np.size(newporetyps)]\\n tpore2 = newporenums\\n tpore1 = np.ones_like(tpore2,dtype=int)*i\\n conns = np.concatenate((conns,np.vstack((tpore1,tpore2)).T),axis=0)\\n self['throat.conns'] = conns\\n bcoords = np.zeros((7,3),dtype=float)\\n coords = self['pore.coords']\\n bcoords[1,:] = [coords[i,0], coords[i,1], 0-Lz*boffset]\\n bcoords[2,:] = [0-Lx*boffset, coords[i,1], coords[i,2]]\\n bcoords[3,:] = [coords[i,0], -Ly*boffset, coords[i,2]]\\n bcoords[4,:] = [coords[i,0], Ly+Ly*boffset, coords[i,2]]\\n bcoords[5,:] = [Lx+Lx*boffset, coords[i,1], coords[i,2]]\\n bcoords[6,:] = [coords[i,0], coords[i,1], Lz+Lz*boffset]\\n newporecoords = bcoords[newporetyps,:]\\n coords = np.concatenate((coords,newporecoords),axis=0)\\n self['pore.coords'] = coords\\n #Reset number of pores and throats (easier than tracking it)\\n nums = np.r_[0:np.shape(coords)[0]]\\n self['pore.numbering'] = nums\\n self['pore.numbering'] = np.ones((nums[-1]+1,),dtype=bool)\\n nums = np.r_[0:np.shape(conns)[0]]\\n self['throat.numbering'] = nums\\n self['throat.numbering'] = np.ones((nums[-1]+1,),dtype=bool)\\n logger.debug(\\\"add_boundaries: end of method\\\")\",\n \"def update_real_constants(self, diff_bound):\\n self.constants.eq_update_constants(diff_bound)\\n self.coefficients = self.constants.get_coefficients()\\n return\",\n \"def SetPRBinConstraint(self, model ) :\\n tot = np.multiply(self.wish, self.dispo)\\n for val in tot :\\n if not val : continue\\n if self.bound>0 : model += val <= self.valBound\\n elif self.bound<0 : model += val >= self.valBound\",\n \"def reset_boundaries(self):\\n self.L = - np.random.uniform(0.0,1.0)\\n self.R = self.L + 1.0\\n self.Ne = 0.0\\n self.Nc = 0.0\",\n \"def impose_boundary_conditions(self) -> _ImposeBoundaryConditionsResults:\\n\\n stiffness = self.get_stiffness_matrix()\\n force_vector = self.get_force_vector()\\n\\n restrained_dofs = self.get_supported_dofs()\\n\\n for axis in range(2):\\n stiffness = np.delete(\\n stiffness,\\n [dof for dof in restrained_dofs],\\n axis=axis,\\n )\\n\\n force_vector = np.delete(\\n force_vector,\\n [dof for dof in restrained_dofs],\\n axis=0,\\n )\\n\\n return _ImposeBoundaryConditionsResults(\\n stiffness=stiffness,\\n force=force_vector,\\n )\",\n \"def __call__(self, u, dx):\\n ru = self.central(u)\\n for i,b in self.boundaries:\\n if __debug__:\\n self.log.debug(\\n \\\"Applying boundary: i = \\\" + repr(i) + \\\", b = \\\" + repr(b)\\n )\\n ru[i] = b(u, apply_at = i)\\n return ru/(dx**self.order)\",\n \"def update_forces(self):\\r\\n # update all the functions\\r\\n self.compute_gravity()\\r\\n self.compute_tides()\\r\\n self.compute_centrifugal()\\r\\n self.compute_coriolis()\\r\\n\\r\\n # add together the forces into the summation function\\r\\n self.forcing.assign(self.ftides+self.gravity +\\r\\n self.centrifugal+self.coriolis)\",\n \"def boundary(self):\\n answer = self.zero()\\n for k, v in self.items():\\n for idx, cube in enumerate(k):\\n acc_dim = sum((cube_l.dimension for cube_l in k[:idx]))\\n for i in range(cube.dimension):\\n for epsilon in (0, 1):\\n new_cube = cube.face(i, epsilon)\\n new_k = k[:idx] + (new_cube,) + k[idx + 1:]\\n sign_exp = (acc_dim + i + epsilon) % 2\\n answer += answer.create({new_k: v * (-1)**sign_exp})\\n return answer\",\n \"def force ( box, strain, r ):\\n\\n import numpy as np\\n from itertools import product\\n import math\\n \\n # It is assumed that positions are in units where box = 1\\n # Forces are calculated in units where sigma = 1 and epsilon = 1\\n # Lees-Edwards boundaries, in sliding brick arrangement\\n # Flow/gradient/vorticity directions are x/y/z == 0/1/2\\n # Uses neighbour lists\\n\\n n = r.shape[0]\\n\\n # Set up vectors to half the cells in neighbourhood of 3x3x3 cells in cubic lattice\\n # The cells are chosen so that if (d0,d1,d2) appears, then (-d0,-d1,-d2) does not.\\n # The last three cells are extra ones, to cope with the sheared system\\n d = np.array ( [ [ 0, 0, 0], [ 1, 0, 0], [ 1, 0, 1], [-1, 0, 1], [ 0, 0, 1], # 5 cells with d1=0\\n [ 1, 1, -1], [ 1, 1, 0], [ 1, 1, 1], # 3 cells with d0= 1, d1=1\\n [ 0, 1, -1], [ 0, 1, 0], [ 0, 1, 1], # 3 cells with d0= 0, d1=1\\n [-1, 1, -1], [-1, 1, 0], [-1, 1, 1], # 3 cells with d0=-1, d1=1\\n [-2, 1, -1], [-2, 1, 0], [-2, 1, 1] ] ) # 3 cells with d0=-2, d1=1\\n\\n r[:,0] = r[:,0] - np.rint(r[:,1])*strain # Extra correction in box=1 units\\n r = r - np.rint(r) # Ensure all atoms in periodic box\\n \\n sr2_ovr = 1.77 # Overlap threshold (pot > 100)\\n r_cut_box = r_cut / box\\n r_cut_box_sq = r_cut_box ** 2\\n box_sq = box ** 2\\n\\n # Initialize\\n f = np.zeros_like(r)\\n total = PotentialType ( pot=0.0, vir=0.0, pyx=0.0, lap=0.0, ovr=False )\\n\\n # Calculate cell index triplets\\n sc = math.floor(box/r_cut) # Number of cells along box edge\\n assert sc >= 3, 'System is too small for cells' # Guard against box being too small\\n c = np.floor((r+0.5)*sc).astype(np.int_) # N*3 array of cell indices for all atoms\\n assert np.all(c>=0) and np.all(c<sc), 'Index error' # Simplistic \\\"guard\\\" against roundoff\\n\\n shift = math.floor(strain*sc) # Strain measured in cell lengths\\n\\n if fast:\\n \\n # Build list of arrays, each array holding positions of atoms in a cell\\n # At the same time, define a matching set of force arrays in each cell\\n # i and j number the atoms in each cell; we do not refer explicitly to indices in r\\n rc, fc = [], [] # Initially empty lists of positions and forces\\n for ci in product(range(sc),repeat=3): # Triple loop over cells\\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\\n rc.append(r[mask,:]) # Copy atom coordinates into array, add to list\\n fc.append(np.zeros_like(rc[-1])) # Zero corresponding forces, add to list\\n\\n for ci1, rci in enumerate(rc): # Loop over i-cells, getting all atoms in each i-cell as an array\\n ci = np.unravel_index(ci1,(sc,sc,sc)) # Get i-cell triple-indices\\n if rci.size==0: # Handle empty cell\\n continue\\n\\n # Set up correct neighbour cell indices\\n if ci[1]==sc-1: # i-cell is in the top layer\\n dd = d.copy() # Standard list copied, including extra 3 cells\\n dd[5:,0] = d[5:,0] - shift # All those looking up need adjustment in the x direction\\n else: # i-cell is not in top layer\\n dd = d[:-3,:].copy() # Last three extra cells are not needed; shift is not needed\\n \\n for dj in dd: # Loop over neighbouring j-cells\\n cj = ci + dj # Compute neighbour j-cell triple-indices\\n cj1 = np.ravel_multi_index(cj,(sc,sc,sc),mode='wrap') # Convert j-cell to single-index\\n rcj = rc[cj1] # Get atoms in j-cell as an array\\n if rcj.size==0: # Handle empty cell\\n continue\\n\\n rij = rci[:,np.newaxis,:]-rcj[np.newaxis,:,:] # Separation vectors for all i and j\\n rij[:,:,0] = rij[:,:,0] - np.rint(rij[:,:,1])*strain # Extra correction in box=1 units\\n rij = rij - np.rint(rij) # PBCs in box=1 units\\n rij_sq = np.sum(rij**2,axis=2) # Squared separations\\n in_range = rij_sq < r_cut_box_sq # Set flags for within cutoff\\n\\n if ci1==cj1:\\n np.fill_diagonal(in_range,False) # Eliminate i==j when i-cell==j-cell\\n np.fill_diagonal(rij_sq,1.0) # Avoid divide-by-zero below\\n\\n rij_sq = rij_sq * box_sq # Now in sigma=1 units\\n rij = rij * box # Now in sigma=1 units\\n sr2 = np.where ( in_range, 1.0/rij_sq, 0.0 ) # (sigma/rij)**2, only if in range\\n ovr = sr2 > sr2_ovr # Overlap if too close\\n sr6 = sr2 ** 3\\n sr12 = sr6 ** 2\\n pot = sr12 - sr6 # LJ potential (cut but not shifted)\\n vir = pot + sr12 # LJ virial\\n pot = np.where ( in_range, pot+0.25, 0.0 ) # WCA LJ pair potential (cut-and-shifted)\\n lap = ( 22.0*sr12 - 5.0*sr6 ) * sr2 # LJ Laplacian\\n fij = vir * sr2 # LJ scalar part of forces\\n fij = rij * fij[:,:,np.newaxis] # LJ pair forces\\n pyx = rij[:,:,1]*fij[:,:,0] # Off-diagonal element of pressure tensor\\n\\n if ci1==cj1: # Correct for double-counting ij and ji when i-cell==j-cell\\n fij = fij / 2\\n total = total + PotentialType ( pot=np.sum(pot)/2, vir=np.sum(vir)/2, \\n pyx=np.sum(pyx)/2, lap=np.sum(lap)/2, ovr=np.any(ovr) )\\n else:\\n total = total + PotentialType ( pot=np.sum(pot), vir=np.sum(vir), \\n pyx=np.sum(pyx), lap=np.sum(lap), ovr=np.any(ovr) )\\n\\n fc[ci1][:,:] = fc[ci1][:,:] + np.sum(fij,axis=1) # Aggregate force on atoms in i-cell\\n fc[cj1][:,:] = fc[cj1][:,:] - np.sum(fij,axis=0) # Aggregate force on atoms in j-cell\\n\\n # Copy forces from list of cell arrays to main force array\\n for ci in product(range(sc),repeat=3): # Triple loop over cells\\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\\n ci1 = np.ravel_multi_index(ci,(sc,sc,sc),mode='wrap') # Single-index\\n f[mask,:] = fc[ci1] # Copy atom forces from correct cell\\n\\n else:\\n \\n # Build list of arrays, each array holding indices of atoms in a cell\\n # ki and kj are atom indices in the r array; i and j number the atoms in each cell\\n k_array = np.arange(n) # Atom indices 0..N-1\\n kc = [] # Initially empty list of indices\\n for ci in product(range(sc),repeat=3): # Triple loop over cells\\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\\n kc.append(k_array[mask]) # Copy atom indices into array, add to list\\n\\n for ci1, kci in enumerate(kc): # Loop over i-cells, getting atom indices as an array\\n ci = np.unravel_index(ci1,(sc,sc,sc)) # Get i-cell triple-indices\\n\\n # Set up correct neighbour cell indices\\n if ci[1]==sc-1: # i-cell is in the top layer\\n dd = d # Standard list copied, including extra 3 cells\\n dd[5:,0] = dd[5:,0] - shift # All those looking up need adjustment in the x direction\\n else:\\n dd = d[:-3,:] # Last three extra cells are not needed; shift is not needed\\n\\n for dj in dd: # Loop over neighbouring j-cells\\n cj = ci + dj # Compute neighbour j-cell triple-indices\\n cj1 = np.ravel_multi_index(cj,(sc,sc,sc),mode='wrap') # Convert to single-index\\n kcj = kc[cj1] # Get indices of atoms in j-cell as an array\\n\\n for i, ki in enumerate(kci): # Loop over individual atoms in i-cell\\n j0 = i+1 if cj1==ci1 else 0 # Only look upwards if i-cell==j-cell\\n if j0 >= kcj.size: # Handles (redundantly) empty j-cell and the case \\n continue # where j-cell==i-cell and i is last atom\\n\\n for kj in kcj[j0:]: # Loop over individual atoms in j-cell\\n rij = r[ki,:]-r[kj,:] # Separation vector\\n rij[0] = rij[0] - np.rint(rij[1])*strain # Extra correction in box=1 units\\n rij = rij - np.rint(rij) # Periodic boundary conditions in box=1 units\\n rij_sq = np.sum(rij**2) # Squared separation\\n\\n if rij_sq < r_cut_box_sq: # Check within cutoff\\n rij_sq = rij_sq * box_sq # Now in sigma=1 units\\n rij = rij * box # Now in sigma=1 units\\n sr2 = 1.0 / rij_sq # (sigma/rij)**2\\n ovr = sr2 > sr2_ovr # Overlap if too close\\n sr6 = sr2 ** 3\\n sr12 = sr6 ** 2\\n pot = sr12 - sr6 # LJ potential (cut but not shifted)\\n vir = pot + sr12 # LJ virial\\n pot = pot + 0.25 # WCA LJ potential (cut-and-shifted)\\n lap = ( 22.0*sr12 - 5.0*sr6 ) * sr2 # LJ Laplacian\\n fij = rij * vir * sr2 # LJ forces\\n pyx = rij[1]*fij[0] # Off-diagonal element of pressure tensor\\n total = total + PotentialType ( pot=pot, vir=vir, pyx=pyx, lap=lap, ovr=ovr )\\n f[ki,:] = f[ki,:] + fij\\n f[kj,:] = f[kj,:] - fij\\n\\n # Multiply results by numerical factors\\n f = f * 24.0 # 24*epsilon\\n total.pot = total.pot * 4.0 # 4*epsilon\\n total.vir = total.vir * 24.0 / 3.0 # 24*epsilon and divide virial by 3\\n total.pyx = total.pyx * 24.0 # 24*epsilon\\n total.lap = total.lap * 24.0 * 2.0 # 24*epsilon and factor 2 for ij and ji\\n \\n return total, f\",\n \"def _redef_via_predef_eqn(self):\\r\\n time = self.current_T # + self.d_T\\r\\n\\r\\n self.Beta = (self.diff_scale * self.thermal_conductivity) / \\\\\\r\\n (self.convect_coeff) \\r\\n self.Epsilon = self.d_T * self.thermal_conductivity / \\\\\\r\\n (self.density * self.heat_capacity)\\r\\n\\r\\n # Source term.\\r\\n def F_func(elem, eta):\\r\\n x = elem.local_to_global(eta)\\r\\n F = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n F -= self.Epsilon * self.redef_F_laplacian(x[0], x[1], time)\\r\\n F += self.redef_dTdt(x[0], x[1], time) * self.d_T\\r\\n return elem.funcs(eta) * F\\r\\n\\r\\n self.vF_vect_vol = et.elems_2_array(self.mesh,\\r\\n F_func,\\r\\n self.node_map,\\r\\n gauss_mult=2) # Use double gp_1D\\r\\n\\r\\n # Boundary term.\\r\\n def f_func(elem, eta):\\r\\n n = elem.guess_normal_vector_global(eta)\\r\\n f = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n x = elem.local_to_global(eta)\\r\\n # Evaluate our boundary term.\\r\\n f += self.Beta * self.redef_f_norm_grad(x[0], x[1], time, n)\\r\\n f += self.redef_dTdt(x[0], x[1], time) * self.d_T\\r\\n return elem.funcs(eta) * f\\r\\n\\r\\n self.vf_vect_bound = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n f_func,\\r\\n self.node_map,\\r\\n gauss_mult=2)\",\n \"def fix_curvature(self) -> None:\\n self.n1.fix = True\\n self.n2.fix = True\",\n \"def calculateExteriorElementBoundaryCoefficients(self):\\n #\\n #get u and grad(u) at the quadrature points\\n #\\n for ci in range(self.nc):\\n self.u[ci].getValuesGlobalExteriorTrace(self.ebqe[('v',ci)],self.ebqe[('u',ci)])\\n if self.ebqe.has_key(('grad(u)',ci)):\\n self.u[ci].getGradientValuesGlobalExteriorTrace(self.ebqe[('grad(v)',ci)],self.ebqe[('grad(u)',ci)])\\n #\\n #get coefficients at the element boundary quadrature points\\n #\\n self.coefficients.evaluate(t = self.timeIntegration.t, c = self.ebqe)\\n #\\n #time integration, handled directly in ELLAM formulation\\n #\\n #ignore numerical flux for now\\n #if self.numericalFlux != None:\\n # self.numericalFlux.calculateExteriorNumericalFlux(self.inflowFlag,self.q,self.ebqe)\\n #flux boundary conditions specified through advective flux\\n for ci,fbcObject in self.fluxBoundaryConditionsObjectsDict.iteritems():\\n for t,g in fbcObject.advectiveFluxBoundaryConditionsDict.iteritems():\\n self.ebqe[('advectiveFlux_bc',ci)][t[0],t[1]] = g(self.ebqe[('x')][t[0],t[1]],self.timeIntegration.t)\\n self.ebqe[('advectiveFlux_bc_flag',ci)][t[0],t[1]] = 1\",\n \"def set_basis(self, maps, methods):\\n self.eval_method = methods\\n\\n def get_grad(maps, shape):\\n bfref0 = eval_base(maps.qp_coor, diff=True).swapaxes(1, 2)\\n if shape == (1,): # scalar variable\\n bfref = bfref0\\n elif len(shape) == 1: # vector variable\\n vec_shape = nm.array(bfref0.shape + shape)\\n vec_shape[1] *= shape[0]\\n bfref = nm.zeros(vec_shape)\\n for ii in nm.arange(shape[0]):\\n slc = slice(ii*bfref0.shape[1], (ii+1)*bfref0.shape[1])\\n bfref[:, slc, ii] = bfref0\\n else: # higher-order tensors variable\\n msg = \\\"Evaluation of basis has not been implemented \\\\\\n for higher-order tensors yet.\\\"\\n raise NotImplementedError(msg)\\n return bfref\\n\\n def get_val(maps, shape):\\n bfref0 = eval_base(maps.qp_coor, diff=False).swapaxes(1, 2)\\n\\n if self.shape == (1,): # scalar variable\\n bfref = bfref0\\n elif len(shape) == 1:\\n vec_shape = nm.array(bfref0.shape)\\n vec_shape[1:3] *= shape[0]\\n bfref = nm.zeros(vec_shape)\\n for ii in nm.arange(shape[0]):\\n slc = slice(ii*bfref0.shape[1], (ii+1)*bfref0.shape[1])\\n bfref[:, slc] = bfref0\\n else: # higher-order tensors variable\\n msg = \\\"Evaluation of basis has not been implemented \\\\\\n for higher-order tensors yet.\\\"\\n raise NotImplementedError(msg)\\n return bfref\\n\\n eval_base = self.interp.poly_spaces['v'].eval_base\\n if self.eval_method[0] == 'val':\\n bfref = get_val(maps, self.shape)\\n\\n elif self.eval_method[0] == 'grad':\\n bfref = get_grad(maps, self.shape)\\n\\n elif self.eval_method[0] == 'div':\\n bfref = get_grad(maps, self.shape)\\n\\n else:\\n raise NotImplementedError(\\\"The method '%s' is not implemented\\\" \\\\\\n % (self.eval_method))\\n\\n self.bfref = bfref\\n self.n_basis = self.bfref.shape[1]\",\n \"def set_rhs(self):\\n k = self.istore[:, 0]\\n ksym = self.stencil.get_symmetric()[k]\\n self.rhs[:] = self.feq[k, np.arange(k.size)] + self.feq[ksym, np.arange(k.size)]\",\n \"def set_rhs(self):\\n k = self.istore[:, 0]\\n ksym = self.stencil.get_symmetric()[k]\\n self.rhs[:] = self.feq[k, np.arange(k.size)] + self.feq[ksym, np.arange(k.size)]\",\n \"def update_forces(self):\\n\\n pass\",\n \"def updateForces(self):\\n for atom1 in range(0, self.numAtoms-1):\\n for atom2 in range(atom1+1, self.numAtoms):\\n self.calculateForce(atom1, atom2)\\n \\n # Multiply by constants \\n for atom in range(0, self.numAtoms):\\n self.atoms[atom].fx *= 48*self.e\\n self.atoms[atom].fy *= 48*self.e\\n self.atoms[atom].fz *= 48*self.e\\n self.atoms[atom].potential *= 4*self.e\",\n \"def term_1(\\n omega1, # vorticity-1\\n omega2, # vorticity-2\\n omega3, # vorticity-3\\n enst, # enstrophy\\n nu_sgs, # turbulent viscosity\\n h = True): # spatial step size\\n #---------------------------------------------------------------------#\\n # Setting default values #\\n #---------------------------------------------------------------------#\\n if h is True:\\n h = 2.0*np.pi/64.0\\n #---------------------------------------------------------------------#\\n # Preallocating space #\\n #---------------------------------------------------------------------#\\n term = np.zeros((64,64,64))\\n #---------------------------------------------------------------------#\\n # Enstrophy term #\\n #---------------------------------------------------------------------#\\n term += np.gradient(\\\\\\n np.gradient(enst, h, edge_order=2)[2], h, edge_order=2)[2]\\n term += np.gradient(\\\\\\n np.gradient(enst, h, edge_order=2)[1], h, edge_order=2)[1]\\n term += np.gradient(\\\\\\n np.gradient(enst, h, edge_order=2)[0], h, edge_order=2)[0]\\n #---------------------------------------------------------------------#\\n # Dissipation #\\n #---------------------------------------------------------------------#\\n omega1_grad = np.gradient(omega1, h, edge_order=2)\\n omega2_grad = np.gradient(omega2, h, edge_order=2)\\n omega3_grad = np.gradient(omega3, h, edge_order=2)\\n term -= np.square(omega1_grad[2])\\n term -= np.square(omega1_grad[1])\\n term -= np.square(omega1_grad[0])\\n term -= np.square(omega2_grad[2])\\n term -= np.square(omega2_grad[1])\\n term -= np.square(omega2_grad[0])\\n term -= np.square(omega3_grad[2])\\n term -= np.square(omega3_grad[1])\\n term -= np.square(omega3_grad[0])\\n #---------------------------------------------------------------------#\\n # Applying the subgrid stress #\\n #---------------------------------------------------------------------#\\n term *= nu_sgs\\n\\n return term\",\n \"def compute_bounds(self, weights, add_coeff, dual_vars, lower_bounds, upper_bounds, store_primal=False):\\n x0_coeff = -weights[0].backward(dual_vars.mus[0])\\n x0 = torch.where(x0_coeff >= 0, lower_bounds[0].unsqueeze(1), upper_bounds[0].unsqueeze(1))\\n bound = utils.bdot(x0, x0_coeff)\\n if store_primal:\\n self.bounds_primal = x0\\n else:\\n del x0\\n del x0_coeff\\n\\n for lay_idx in range(1, len(weights)):\\n lbs = lower_bounds[lay_idx].unsqueeze(1).clamp(None, 0)\\n ubs = upper_bounds[lay_idx].unsqueeze(1).clamp(0, None)\\n neg_bias = ((lbs * ubs) / (ubs - lbs))\\n neg_bias.masked_fill_(ubs == lbs, 0) # cover case in which ubs & lbs coincide\\n bound += utils.bdot(dual_vars.lambdas[lay_idx - 1].clamp(0, None), neg_bias)\\n bound -= utils.bdot(dual_vars.mus[lay_idx - 1], weights[lay_idx - 1].get_bias())\\n\\n bound += utils.bdot(add_coeff, weights[-1].get_bias())\\n return bound\",\n \"def setup_observation_term(background_data_dict,\\n obs_type_vector, obs_data_vector, obs_lat_vector, obs_lon_vector,\\n background_type_vector, background_data_vector, background_lat_vector, background_lon_vector,\\n direct_obs_operator,\\n analysis_increment_vector_symbol,\\n increment_data=0.001):\\n linearized_obs_operator = sympy.Matrix(\\n numpy.ones((len(obs_type_vector), len(background_type_vector))))\\n background_derived_obs = sympy.Matrix(\\n numpy.ones((len(obs_type_vector), 1)))\\n\\n for i_obs in range(0, len(obs_data_vector)):\\n cur_obs_type = str(obs_type_vector[i_obs])\\n cur_obs_lat = float(obs_lat_vector[i_obs])\\n cur_obs_lon = float(obs_lon_vector[i_obs])\\n\\n cur_bk_derived_obs_operator = direct_obs_operator[cur_obs_type]\\n required_bk_vars = cur_bk_derived_obs_operator.free_symbols\\n \\n # 1. calculate h(x):\\n bkg_shape = background_data_dict['lat'].shape\\n bkg_weight_0 = 0\\n bkg_weight_1 = 0\\n for ii in range(0, bkg_shape[0]):\\n for jj in range(0, bkg_shape[1]):\\n cur_bk_lat = background_data_dict['lat'][ii, jj]\\n cur_bk_lon = background_data_dict['lon'][ii, jj]\\n\\n cur_obs_operator_input = {}\\n for required_bk_var in required_bk_vars:\\n cur_obs_operator_input[str(required_bk_var)] = background_data_dict[str(required_bk_var)][ii, jj]\\n\\n cur_distance = math.sqrt((cur_obs_lat - cur_bk_lat)**2 + (cur_obs_lon - cur_bk_lon)**2)\\n cur_distance_weight_0 = (direct_obs_operator[cur_obs_type].subs(cur_obs_operator_input))/float(cur_distance**2)\\n cur_distance_weight_1 = 1.0/float(cur_distance**2)\\n bkg_weight_0 = bkg_weight_0 + cur_distance_weight_0\\n bkg_weight_1 = bkg_weight_1 + cur_distance_weight_1\\n \\n background_derived_obs[i_obs, 0] = bkg_weight_0/bkg_weight_1\\n final_bkg_weight_1 = bkg_weight_1\\n \\n # 2. find linearized observation operator\\n # n = 0\\n for i_bkg in range(0, len(background_type_vector)):\\n cur_bk_lat = float(background_lat_vector[i_bkg])\\n cur_bk_lon = float(background_lon_vector[i_bkg])\\n cur_bk_type = str(background_type_vector[i_bkg])\\n \\n cur_distance = math.sqrt((cur_obs_lat - cur_bk_lat)**2 + (cur_obs_lon - cur_bk_lon)**2)\\n cur_distance_weight_0 = cur_distance ** 2\\n distance_term = 1.0/(cur_distance_weight_0 * final_bkg_weight_1)\\n \\n l = sympy.diff(direct_obs_operator[cur_obs_type], cur_bk_type)\\n linearized_obs_operator[i_obs, i_bkg] = distance_term*l.subs(\\n {cur_bk_type: float(background_data_vector[i_bkg])})\\n \\n linearized_obs_operator_with_increments = \\\\\\n linearized_obs_operator*analysis_increment_vector_symbol\\n \\n # get the innovation:\\n innovation = obs_data_vector - background_derived_obs - \\\\\\n linearized_obs_operator_with_increments\\n return linearized_obs_operator, innovation, background_derived_obs\",\n \"def build_constraints_boundaries(self):\\n\\n # Trapezoidal and Hermite-Simpson methods can't compute\\n # defects at the last node contrary to pseudospectral methods\\n coll_method = self.options['tr_method'] in [\\n 'trapezoidal', 'hermite-simpson']\\n n_nodes = self.problem.prm['n_nodes'] - \\\\\\n 1 if coll_method else self.problem.prm['n_nodes']\\n\\n # Defects lower and upper boundaries\\n defects_low = np.zeros(\\n self.problem.prm['n_states'] * n_nodes)\\n defects_upp = np.zeros(\\n self.problem.prm['n_states'] * n_nodes)\\n\\n # Path lower and upper boundaries\\n path_low = np.hstack([self.problem.low_bnd.path]\\n * (self.problem.prm['n_nodes']))\\n path_upp = np.hstack([self.problem.upp_bnd.path]\\n * (self.problem.prm['n_nodes']))\\n\\n # Events lower and upper boundaries\\n event_low = self.problem.low_bnd.event\\n event_upp = self.problem.upp_bnd.event\\n\\n # Assembly of the lower and upper boundaries vectors\\n low = np.concatenate((defects_low, path_low, event_low))\\n upp = np.concatenate((defects_upp, path_upp, event_upp))\\n\\n return low, upp\",\n \"def boundary_conditions(self):\\n pass\",\n \"def relax(self):\\n # print(\\\"putin\\\", self.level.rhs.reshape(-1)[:])\\n # print(\\\"getout\\\", self.solver(self.level.rhs.reshape(-1)))\\n\\n self.level.mid[:] = self.solver(self.level.rhs.reshape(-1)).reshape(self.level.mid.shape)\",\n \"def update_forces(self):\\n element: Cell\\n element1: Cell\\n element2: Cell\\n for element in self.cells:\\n element.force = Vector(.0, .0, .0)\\n\\n tmp_systems = self.cells.copy()\\n to_delete = set()\\n for element1 in self.cells:\\n for element2 in self.cells:\\n if element1 == element2:\\n continue\\n if element2.distance(element1) <= element2.r_max:\\n force = find_force(element1, element2)\\n element1.force += force\\n element2.force += -force\\n to_delete.add(element2)\\n tmp_systems -= to_delete\\n to_delete.clear()\",\n \"def applyForce(self, F, dT):\",\n \"def add_cp_le_RBM_terms_alt(K, cons_pot_mesh, lin_geo_mesh):\\n num_faces = cons_pot_mesh.get_faces().shape[0]\\n x_c = lin_geo_mesh.get_centroid()\\n w = lin_geo_mesh.get_w()\\n A_m = lin_geo_mesh.get_A_m()\\n S_D = lin_geo_mesh.get_surface_area()\\n\\n for face_num in range(num_faces):\\n face_nodes = lin_geo_mesh.get_tri_nodes(face_num)\\n face_hs = lin_geo_mesh.get_hs(face_num)\\n face_center = lin_geo_mesh.get_tri_center(face_num)\\n v_sub_mat = (1. / S_D) * (np.identity(3) * 0.5 * face_hs) # simple integral\\n tmp_omega = []\\n for m in range(3):\\n def make_omega_quad(w, A_m):\\n def omega_quad(xi, eta, nodes):\\n pos = geo.linear_interp(xi, eta, nodes)\\n X = pos - x_c\\n return np.cross(w, X)\\n return omega_quad\\n tmp_omega.append(gq.int_over_tri_lin(\\n make_omega_quad(w[m], A_m[m]),\\n face_nodes,\\n face_hs,\\n ))\\n for src_num in range(num_faces):\\n K[(3 * src_num):(3 * src_num + 3),\\n (3 * face_num):(3 * face_num + 3)] += v_sub_mat\\n src_center = cons_pot_mesh.get_node(src_num)\\n X_0 = src_center - x_c\\n tmp_arr = []\\n for m in range(3):\\n tmp_arr.append(np.outer((1./ A_m[m]) * np.cross(w[m], X_0), tmp_omega[m]))\\n tmp_arr = np.array(tmp_arr)\\n omega_mat = np.sum(tmp_arr, axis=0)\\n K[(3 * src_num):(3 * src_num + 3),\\n (3 * face_num):(3 * face_num + 3)] += omega_mat\",\n \"def do_relax(self):\\n raise NotImplementedError\",\n \"def regularize_if_necessary(self) -> None:\\n # As described in [wang2014], all entities and relations are used to compute the regularization term\\n # which enforces the defined soft constraints.\\n super().regularize_if_necessary(\\n self.entity_embeddings.weight,\\n self.normal_vector_embeddings.weight,\\n self.relation_embeddings.weight,\\n )\",\n \"def test_update_boundary_opt(self):\\n self.set_up()\\n boundary_opt_new = np.hstack((self.vmecOptimization.boundary_opt,\\n self.vmecOptimization.boundary_opt))\\n self.assertRaises(ValueError,self.vmecOptimization.update_boundary_opt,\\n boundary_opt_new)\\n boundary_opt_new = np.copy(self.vmecOptimization.boundary_opt)\\n boundary_opt_new[0] = 1\\n self.vmecOptimization.update_boundary_opt(boundary_opt_new)\\n self.assertEqual(1,self.vmecOptimization.boundary_opt[0])\\n self.tear_down()\",\n \"def calculate_thickness_terms(self):\\n\\n self.calculate_min_thickness()\\n self._calculate_driven_mass()\\n self._calculate_resonant_frequency()\\n self._calculate_quilting_error()\",\n \"def incumbent(self):\\n return self.boundary_handler.repair(self.mean)\",\n \"def _set_bounds(b, x, n):\\n for j in range(1, n - 1):\\n for i in range(1, n - 1):\\n x[index_of(i, j, 0, n)] = -x[index_of(i, j, 1, n)] if b == 3 else x[index_of(i, j, 1, n)]\\n x[index_of(i, j, 0, n - 1)] = -x[index_of(i, j, 1, n - 2)] if b == 3 else x[index_of(i, j, 1, n - 2)]\\n for k in range(1, n - 1):\\n for i in range(1, n - 1):\\n x[index_of(i, 0, k, n)] = -x[index_of(i, 1, k, n)] if b == 2 else x[index_of(i, 1, k, n)]\\n x[index_of(i, n - 1, 0, n - 1)] = -x[index_of(i, n - 2, k, n - 2)] if b == 2 else x[\\n index_of(i, n - 2, k, n - 2)]\\n for k in range(1, n - 1):\\n for j in range(1, n - 1):\\n x[index_of(0, j, k, n)] = -x[index_of(1, j, k, n)] if b == 1 else x[index_of(1, j, k, n)]\\n x[index_of(n - 1, j, k, n - 1)] = -x[index_of(n - 2, j, k, n)] if b == 1 else x[\\n index_of(n - 2, j, k, n)]\\n\\n x[index_of(0, 0, 0, n)] = 1 / 3 * (x[index_of(1, 0, 0, n)] + x[index_of(0, 1, 0, n)] + x[index_of(0, 0, 1, n)])\\n x[index_of(0, n - 1, 0, n)] = 1 / 3 * (\\n x[index_of(1, n - 1, 0, n)] + x[index_of(0, n - 2, 0, n)] + x[index_of(0, n - 1, 1, n)])\\n x[index_of(0, 0, n - 1, n)] = 1 / 3 * (\\n x[index_of(1, 0, n - 1, n)] + x[index_of(0, 1, n - 1, n)] + x[index_of(0, 0, n - 2, n)])\\n x[index_of(0, n - 1, n - 1, n)] = 1 / 3 * (\\n x[index_of(1, n - 1, n - 1, n)] + x[index_of(0, n - 2, n - 1, n)] + x[index_of(0, n - 1, n - 2, n)])\\n x[index_of(n - 1, 0, 0, n)] = 1 / 3 * (\\n x[index_of(n - 2, 0, 0, n)] + x[index_of(n - 1, 1, 0, n)] + x[index_of(n - 1, 0, 1, n)])\\n x[index_of(n - 1, n - 1, 0, n)] = 1 / 3 * (\\n x[index_of(n - 2, n - 1, 0, n)] + x[index_of(n - 1, n - 2, 0, n)] + x[index_of(n - 1, n - 1, 1, n)])\\n x[index_of(n - 1, 0, n - 1, n)] = 1 / 3 * (\\n x[index_of(n - 2, 0, n - 1, n)] + x[index_of(n - 1, 1, n - 1, n)] + x[index_of(n - 1, 0, n - 2, n)])\\n x[index_of(n - 1, n - 1, n - 1, n)] = 1 / 3 * (\\n x[index_of(n - 2, n - 1, n - 1, n)] + x[index_of(n - 1, n - 2, n - 1, n)] + x[\\n index_of(n - 1, n - 1, n - 2, n)])\",\n \"def set_initial_condition(self):\\n X0 = np.array([0.5, 0.5])\\n XB = self.bary\\n q0 = 1 + np.exp(-0.5*(np.sum((XB-X0[np.newaxis])**2., axis=1))/0.1**2)\\n q1 = np.zeros(q0.shape)\\n #import pdb; pdb.set_trace()\\n return np.array([q0, q1, q1]).T\",\n \"def set_boundary(self, t):\\n gw_level = self.gwhead[t]\\n if np.isfinite(gw_level):\\n self.gw.potential = gw_level\",\n \"def __get_new_restriction_branch_and_bound(self, tableau, var_col, b_value):\\n restriction_row = np.zeros((tableau.get_tableau_num_cols())).astype('object')\\n restriction_row[var_col] = 1\\n restriction_row[tableau.get_tableau_num_cols() - 1] = b_value\\n\\n for i in xrange(0, len(restriction_row)):\\n restriction_row[i] = Fraction(restriction_row[i])\\n\\n return restriction_row\",\n \"def compute_ghost_series(self,terms):\\n\\t\\tp=self.p\\n\\t\\tcomp=self.comp\\n\\t\\tf1=self.f1\\n\\t\\tf2=self.f2\\n\\n\\t\\tghost_coefs = [[] for i in range(terms+1)]\\n\\n\\n\\t\\tk=comp;\\n\\t\\tif k==0 or k==1:\\n\\t\\t\\tk=k+p-1\\n\\n\\t\\t## Precompute the needed dimensions\\n\\t\\tself.f1v = [f1(k)]\\n\\t\\tself.f2v = [f2(k)]\\n\\t\\tk = k + p-1\\n\\t\\twhile self.f1v[len(self.f1v)-1] <= terms+1:\\n\\t\\t\\tself.f1v += [f1(k)]\\n\\t\\t\\tself.f2v += [f2(k)]\\n\\t\\t\\tk = k + p-1\\n\\t\\t\\n\\t\\t## Starting at weight 2, we run through weights in the component,\\n\\t\\t## compute the associated indices, and then record the weights at those\\n\\t\\t## indices with appropriate multiplicities\\n\\n\\t\\tk = comp;\\n\\t\\tif k==0 or k==1:\\n\\t\\t\\tk=k+p-1\\n\\t\\tn = 0\\n\\n\\t\\tinds = range(self.f1v[n]+1,self.f1v[n]+self.f2v[n])\\n\\t\\twhile (len(inds)==0 or inds[0]<=terms+1):\\n\\t\\t\\t## This loops adds the weights to the appropriate indices with the appropriate multiplicities\\n\\t\\t\\tfor m in range(floor((len(inds)+1)/2)):\\n\\t\\t\\t\\tif m < floor(len(inds)/2):\\n\\t\\t\\t\\t\\tif inds[m]<=terms:\\n\\t\\t\\t\\t\\t\\tghost_coefs[inds[m]] += [(k,m+1)]\\n\\t\\t\\t\\t\\tif (inds[len(inds)-1-m]<=terms):\\n\\t\\t\\t\\t\\t\\tghost_coefs[inds[len(inds)-1-m]] += [(k,m+1)]\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tif inds[m]<=terms:\\n\\t\\t\\t\\t\\t\\tghost_coefs[inds[m]] += [(k,m+1)]\\n\\t\\t\\tk = k + p-1\\n\\t\\t\\tn = n + 1\\n\\t\\t\\tinds = range(self.f1v[n]+1,self.f1v[n]+self.f2v[n])\\n\\t\\tself.series=ghost_coefs\",\n \"def normalize_all(self):\\n #for i, vector in enumerate(self.real_vectors):\\n # self.real_vectors[i] /= np.linalg.norm(vector)\\n self.vectors /= np.linalg.norm(self.vectors, axis=1).reshape(-1,1)\\n for i, vector in enumerate(self.real_vectors):\\n vector.set(self.vectors[i])\",\n \"def additional_equations(self, k):\\n ######################################################################\\n # equation for saturated liquid at hot side outlet\\n if self.subcooling.val is False:\\n o1 = self.outl[0].to_flow()\\n self.residual[k] = o1[2] - h_mix_pQ(o1, 0)\\n k += 1\",\n \"def SetPRBinCatConstraint( self, model ) :\\n tot = np.dot( self.wish.T, self.dispo )\\n for val in tot :\\n if not val : continue\\n if self.bound>0 : model += val <= self.valBound\\n elif self.bound<0 : model += val >= self.valBound\",\n \"def update(self):\\n self._g, self._B = self._constraint_assembler.preallocate_g_and_B(self._no_of_dofs_unconstrained,\\n self._dofidxs(),\\n self._no_of_constraints_by_object())\",\n \"def set_freq_relaxation(self):\\n self.num_omega=5\\n self.omega=np.zeros(self.num_omega)\\n iOmH = 3 ; # indexing for the frequencies.\\n iOmX = 1 ; #\\n # First determine the frequencies omega and J from given inputs.\\n self.omega[iOmH] = -1.0*self.gH.gamma*self.B_0*self.time_fact\\n self.omega[iOmX] = -1.0*self.gX.gamma*self.B_0*self.time_fact\\n self.omega[iOmH-iOmX] = (self.omega[iOmH]-self.omega[iOmX])\\n self.omega[iOmH+iOmX] = (self.omega[iOmH]+self.omega[iOmX])\",\n \"def _merge_boundaries(self):\\n optical = self._amalgamated_optical\\n if bool(optical):\\n optical[\\\"catagory\\\"] = OPTICAL * tf.ones_like(\\n optical[\\\"xp\\\"],\\n dtype=tf.int64\\n )\\n self._optical_count = tf.shape(\\n optical[\\\"xp\\\"],\\n out_type=tf.int64\\n )[0]\\n else:\\n self._optical_count = 0\\n \\n stop = self._amalgamated_stop\\n if bool(stop):\\n stop[\\\"catagory\\\"] = STOP * tf.ones_like(\\n stop[\\\"xp\\\"],\\n dtype=tf.int64\\n )\\n self._stop_count = tf.shape(\\n stop[\\\"xp\\\"],\\n out_type=tf.int64\\n )[0]\\n else:\\n self._stop_count = 0\\n \\n target = self._amalgamated_target\\n if bool(target):\\n target[\\\"catagory\\\"] = TARGET * tf.ones_like(\\n target[\\\"xp\\\"],\\n dtype=tf.int64\\n )\\n self._target_count = tf.shape(\\n target[\\\"xp\\\"],\\n out_type=tf.int64\\n )[0]\\n else:\\n self._target_count = 0\\n \\n self._merged = amalgamate(\\n [optical, stop, target], \\n TRIANGLE_GEO_SIG | {\\\"catagory\\\"}\\n )\",\n \"def boundary(self):\\n\\n answer = self.zero()\\n if self.torsion == 2:\\n for k in self.keys():\\n for idx in range(0, len(k)):\\n bdry_summand = k[:idx] + k[idx + 1:]\\n if k[idx] in bdry_summand:\\n answer += self.create({bdry_summand: 1})\\n return answer\\n if self.convention == 'Berger-Fresse':\\n for k, v in self.items():\\n # determining the signs of the summands\\n signs = {}\\n alternating_sign = 1\\n for idx, i in enumerate(k):\\n if i in k[idx + 1:]:\\n signs[idx] = alternating_sign\\n alternating_sign *= (-1)\\n elif i in k[:idx]:\\n occurs = (pos for pos, j in enumerate(k[:idx]) if i == j)\\n signs[idx] = signs[max(occurs)] * (-1)\\n else:\\n signs[idx] = 0\\n # computing the summands\\n for idx in range(0, len(k)):\\n bdry_summand = k[:idx] + k[idx + 1:]\\n if k[idx] in bdry_summand:\\n answer += self.create({bdry_summand: signs[idx] * v})\\n if self.convention == 'McClure-Smith':\\n for k, v in self.items():\\n sign = 1\\n for i in range(1, max(k) + 1):\\n for idx in (idx for idx, j in enumerate(k) if j == i):\\n new_k = k[:idx] + k[idx + 1:]\\n if k[idx] in new_k:\\n answer += answer.create({new_k: v * sign})\\n sign *= -1\\n sign *= -1\\n return answer\",\n \"def equalize(pair, bias_axis, word_to_vec_map):\\n\\n ### START CODE HERE ###\\n # Step 1: Select word vector representation of \\\"word\\\". Use word_to_vec_map. (≈ 2 lines)\\n w1, w2 = pair\\n e_w1, e_w2 = (word_to_vec_map[w1], word_to_vec_map[w2])\\n\\n # Step 2: Compute the mean of e_w1 and e_w2 (≈ 1 line)\\n mu = (e_w1 + e_w2) / 2\\n\\n # Step 3: Compute the projections of mu over the bias axis and the orthogonal axis (≈ 2 lines)\\n mu_B = np.dot(mu, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\\n mu_orth = mu - mu_B\\n\\n # Step 4: Use equations (7) and (8) to compute e_w1B and e_w2B (≈2 lines)\\n e_w1B = np.dot(e_w1, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\\n e_w2B = np.dot(e_w2, bias_axis) / np.sum(np.dot(bias_axis, bias_axis)) * bias_axis\\n\\n # Step 5: Adjust the Bias part of e_w1B and e_w2B using the formulas (9) and (10) given above (≈2 lines)\\n corrected_e_w1B = np.sqrt(np.abs(1 - np.sum(np.dot(mu_orth, mu_orth)))) * (e_w1B - mu_B) / np.sqrt(\\n np.sum(np.dot(e_w1 - mu_orth - mu_B, e_w1 - mu_orth - mu_B)))\\n corrected_e_w2B = np.sqrt(np.abs(1 - np.sum(np.dot(mu_orth, mu_orth)))) * (e_w2B - mu_B) / np.sqrt(\\n np.sum(np.dot(e_w2 - mu_orth - mu_B, e_w2 - mu_orth - mu_B)))\\n\\n # Step 6: Debias by equalizing e1 and e2 to the sum of their corrected projections (≈2 lines)\\n e1 = corrected_e_w1B + mu_orth\\n e2 = corrected_e_w2B + mu_orth\\n\\n ### END CODE HERE ###\\n\\n return e1, e2\",\n \"def calculateRightHandSide(self):\\n\\n #each element triangulation.simplices is a list with the point indices of the triangle\\n for ele,triPoints in enumerate(self.triangulation.simplices):\\n elementRHS = self.calculateElementRightHandSide(ele)\\n\\n for index,entry in enumerate(elementRHS):\\n self.rightHandSide[triPoints[index]] += entry\\n\\n #overwrite the values at the prescribed boundaries condition\\n for indexValue in self.prescribedValues:\\n self.rightHandSide[int(indexValue[0])] = indexValue[1]\\n #print(self.rightHandSide)\",\n \"def add_cp_le_RBM_terms(K, cons_pot_mesh, lin_geo_mesh):\\n num_faces = cons_pot_mesh.get_faces().shape[0]\\n x_c = lin_geo_mesh.get_centroid()\\n w = lin_geo_mesh.get_w()\\n A_m = lin_geo_mesh.get_A_m()\\n S_D = lin_geo_mesh.get_surface_area()\\n\\n for face_num in range(num_faces):\\n face_nodes = lin_geo_mesh.get_tri_nodes(face_num)\\n face_hs = lin_geo_mesh.get_hs(face_num)\\n v_sub_mat = (1. / S_D) * (np.identity(3) * 0.5 * face_hs) # simple integral\\n def omega_quad(xi, eta, nodes):\\n pos = geo.linear_interp(xi, eta, nodes)\\n X = pos - x_c\\n return np.einsum(\\\"lrs,s->lr\\\", geo.LC_3, X)\\n tmp_omega = gq.int_over_tri_lin(\\n omega_quad,\\n face_nodes,\\n face_hs,\\n )\\n tmp_arr = []\\n for m in range(3):\\n tmp_arr.append((1./ A_m[m]) * np.outer(w[m], np.einsum(\\\"l,ls\\\", w[m], tmp_omega)))\\n tmp_arr = np.array(tmp_arr)\\n tmp_omega_mat = np.sum(tmp_arr, axis=0)\\n for src_num in range(num_faces):\\n K[(3 * src_num):(3 * src_num + 3),\\n (3 * face_num):(3 * face_num + 3)] += v_sub_mat\\n #src_center = cons_pot_mesh.get_node(src_num)\\n src_center = lin_geo_mesh.get_tri_center(src_num)\\n X_0 = src_center - x_c\\n omega_mat = np.einsum(\\\"ijk,js,k->is\\\", geo.LC_3, tmp_omega_mat, X_0)\\n K[(3 * src_num):(3 * src_num + 3),\\n (3 * face_num):(3 * face_num + 3)] += omega_mat\",\n \"def set_bc(self, problem):\\n bcs = problem.bcs\\n n_bound = cfg.const['N_GHOST_CELLS']\\n # Left X-b.c.\\n for i in range(0, self.i_min):\\n for j in range(self.j_min, self.j_max):\\n for k in range(self.k_min, self.k_max): \\n if bcs[0] == 't': \\n self.U[i][j][k] = self.U[self.i_min][j][k]\\n elif bcs[0] == 'w':\\n for num in [0, 2, 3, 4]: # 0 -> 3, 1 -> 2, i_min-1 -> i_min, i_min-2 -> i_min+1\\n self.U[i][j][k][num] = self.U[self.i_min + (self.i_min - i - 1)][j][k][num]\\n for num in [1]:\\n self.U[i][j][k][num] = - self.U[self.i_min + (self.i_min - i - 1)][j][k][num]\\n else:\\n print(\\\"Errof field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\\n # Right X-b.c.\\n for i in range(self.i_max, self.i_max+n_bound):\\n for j in range(self.j_min, self.j_max):\\n for k in range(self.k_min, self.k_max): \\n if bcs[1] == 't':\\n self.U[i][j][k] = self.U[self.i_max-1][j][k]\\n elif bcs[1] == 'w':\\n for num in [0, 2, 3, 4]: # i_max -> i_max-1 , i_max+1-> i_max-2\\n self.U[i][j][k][num] = self.U[self.i_max - (i - self.i_max + 1)][j][k][num]\\n for num in [1]:\\n self.U[i][j][k][num] = - self.U[self.i_max - (i - self.i_max + 1)][j][k][num]\\n else:\\n print(\\\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\\n # Left Y-b.c.\\n for i in range(0, self.i_max+n_bound):\\n for j in range(0, self.j_min):\\n for k in range(self.k_min, self.k_max): \\n if bcs[2] == 't':\\n self.U[i][j][k] = self.U[i][self.j_min][k]\\n elif bcs[2] == 'w':\\n for num in [0, 1, 3, 4]:\\n self.U[i][j][k][num] = self.U[i][self.j_min + (self.j_min - j - 1)][k][num]\\n for num in [2]:\\n self.U[i][j][k][num] = - self.U[i][self.j_min + (self.j_min - j - 1)][k][num]\\n else:\\n print(\\\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\\n # Right Y-b.c.\\n for i in range(0, self.i_max+n_bound):\\n for j in range(self.j_max, self.j_max+n_bound):\\n for k in range(self.k_min, self.k_max): \\n if bcs[3] == 't':\\n self.U[i][j][k] = self.U[i][self.j_max-1][k]\\n elif bcs[3] == 'w':\\n for num in [0, 1, 3, 4]:\\n self.U[i][j][k][num] = self.U[i][self.j_max - (j - self.j_max + 1)][k][num]\\n for num in [2]:\\n self.U[i][j][k][num] = -self.U[i][self.j_max - (j - self.j_max + 1)][k][num]\\n else:\\n print(\\\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\\n # Left Z-b.c.\\n for i in range(0, self.i_max+n_bound):\\n for j in range(0, self.j_max+n_bound):\\n for k in range(0, self.k_min): \\n if bcs[4] == 't':\\n self.U[i][j][k] = self.U[i][j][self.k_min]\\n elif bcs[4] == 'w':\\n for num in [0, 1, 2, 4]:\\n self.U[i][j][k][num] = self.U[i][j][self.k_min + (self.k_min - k - 1)][num]\\n for num in [3]:\\n self.U[i][j][k][num] = - self.U[i][j][self.k_min + (self.k_min - k - 1)][num]\\n else:\\n print(\\\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\\n # Right Z-b.c.\\n for i in range(0, self.i_max+n_bound):\\n for j in range(0, self.j_max+n_bound):\\n for k in range(self.k_max, self.k_max+n_bound):\\n if bcs[5] == 't':\\n self.U[i][j][k] = self.U[i][j][self.k_max-1]\\n elif bcs[5] == 'w':\\n for num in [0, 1, 2, 4]:\\n self.U[i][j][k][num] = self.U[i][j][self.k_max - (k - self.k_max + 1)][num]\\n for num in [3]:\\n self.U[i][j][k][num] = - self.U[i][j][self.k_max - (k - self.k_max + 1)][num]\\n else:\\n print(\\\"Error field.set_ics(): only wall-type and transmissive boundaries supported! Bye!\\\")\",\n \"def ComputeBasis(self, p_float=..., p_float=..., p_float=..., *args, **kwargs):\\n ...\",\n \"def set_bounds_atom(self,bounds):\\n assert bounds.shape == (2,self.Phi.d)\\n self.bounds = bounds # data bounds\\n self.bounds_atom = bounds.T.tolist()\\n for i in range(self.Phi.d): # bounds for the variance in each dimension\\n max_variance_this_dimension = (bounds[1][i]-bounds[0][i])**2\\n self.bounds_atom.append([self.variance_relative_lowerbound*max_variance_this_dimension,\\n self.variance_relative_upperbound*max_variance_this_dimension])\",\n \"def real_reduce(self, bound, large_constant):\\n approximation_matrix = self.generate_approximation_matrix(large_constant)\\n LLL_matrix = self.generate_LLL_matrix(approximation_matrix)\\n GS_matrix = self.generate_GS_matrix(LLL_matrix) \\n minimal_vector_bound = self.calculate_minimal_vector_bound(large_constant, LLL_matrix, GS_matrix)\\n S, T = self.calculate_S_and_T(self.coefficients[\\\"Z_bounds\\\"])\\n print('ST',T**2 + S)\\n new_bound = self.real_reduce_new_bound(large_constant, minimal_vector_bound, S, T)\\n print('diff_bound',new_bound)\\n return new_bound\",\n \"def additional_equations(self, k):\\n ######################################################################\\n # equation for saturated gas at hot side outlet\\n o1 = self.outl[0].to_flow()\\n self.residual[k] = o1[2] - h_mix_pQ(o1, 1)\",\n \"def test_handling_of_variable_bound_sums_in_merge(free_alg):\\n\\n dr = free_alg\\n p = dr.names\\n\\n x = IndexedBase('x')\\n v = p.v\\n i = p.i\\n r = p.R\\n\\n first = dr.sum((i, r), x[i] * v[i])\\n\\n # First trial, when the ranges are really the same.\\n assert dr.simplify(\\n first - dr.sum((i, r), x[i] * v[i])\\n ) == 0\\n\\n # This time, they should not be merged.\\n assert dr.simplify(\\n first - dr.sum((i, r[0, Symbol('n')]), x[i] * v[i])\\n ).n_terms == 2\",\n \"def compute_bound(self, sstats, totals):\\n w = self.vocab_len\\n t = self.num_time_slices\\n\\n term_1 = 0\\n term_2 = 0\\n term_3 = 0\\n\\n val = 0\\n ent = 0\\n\\n chain_variance = self.chain_variance\\n # computing mean, fwd_mean\\n self.mean, self.fwd_mean = \\\\\\n (np.array(x) for x in zip(*(self.compute_post_mean(w, self.chain_variance) for w in range(w))))\\n self.zeta = self.update_zeta()\\n\\n val = sum(self.variance[w][0] - self.variance[w][t] for w in range(w)) / 2 * chain_variance\\n\\n logger.info(\\\"Computing bound, all times\\\")\\n\\n for t in range(1, t + 1):\\n term_1 = 0.0\\n term_2 = 0.0\\n ent = 0.0\\n for w in range(w):\\n\\n m = self.mean[w][t]\\n prev_m = self.mean[w][t - 1]\\n\\n v = self.variance[w][t]\\n\\n # w_phi_l is only used in Document Influence Model; the values are always zero in this case\\n # w_phi_l = sslm.w_phi_l[w][t - 1]\\n # exp_i = np.exp(-prev_m)\\n # term_1 += (np.power(m - prev_m - (w_phi_l * exp_i), 2) / (2 * chain_variance)) -\\n # (v / chain_variance) - np.log(chain_variance)\\n\\n term_1 += \\\\\\n (np.power(m - prev_m, 2) / (2 * chain_variance)) - (v / chain_variance) - np.log(chain_variance)\\n term_2 += sstats[w][t - 1] * m\\n ent += np.log(v) / 2 # note the 2pi's cancel with term1 (see doc)\\n\\n term_3 = -totals[t - 1] * np.log(self.zeta[t - 1])\\n val += term_2 + term_3 + ent - term_1\\n\\n return val\",\n \"def _construct_compute_fe_terms(self):\\n # setup some symbolic variables for theano to deal with\\n xi = T.matrix()\\n xo = T.matrix()\\n _, hi_zmuv = self._construct_zmuv_samples(xi, 1)\\n # construct values to output\\n nll = self.nlli[-1]\\n kld = self.kld_z.flatten() + self.kld_hi_q2p.flatten()\\n # compile theano function for a one-sample free-energy estimate\\n fe_term_sample = theano.function(inputs=[ xi, xo ], \\\\\\n outputs=[nll, kld], \\\\\\n givens={self.x_in: xi, \\\\\\n self.x_out: xo, \\\\\\n self.hi_zmuv: hi_zmuv}, \\\\\\n updates=self.scan_updates)\\n # construct a wrapper function for multi-sample free-energy estimate\\n def fe_term_estimator(XI, XO, sample_count):\\n # compute a multi-sample estimate of variational free-energy\\n nll_sum = np.zeros((XI.shape[0],))\\n kld_sum = np.zeros((XI.shape[0],))\\n for i in range(sample_count):\\n result = fe_term_sample(XI, XO)\\n nll_sum += result[0].ravel()\\n kld_sum += result[1].ravel()\\n mean_nll = nll_sum / float(sample_count)\\n mean_kld = kld_sum / float(sample_count)\\n return [mean_nll, mean_kld]\\n return fe_term_estimator\",\n \"def removeFixedEffect(self, index=None):\\n if self._n_terms==0:\\n pass\\n if index is None or index==(self._n_terms-1):\\n\\n self._n_terms-=1\\n F = self._F.pop() #= self.F[:-1]\\n A = self._A.pop() #= self.A[:-1]\\n self._A_identity.pop() #= self.A_identity[:-1]\\n REML_term = self._REML_term.pop()# = self.REML_term[:-1]\\n self._B.pop()# = self.B[:-1]\\n self._n_fixed_effs-=F.shape[1]*A.shape[0]\\n if REML_term:\\n self._n_fixed_effs_REML-=F.shape[1]*A.shape[0]\\n\\n pass\\n elif index >= self.n_terms:\\n raise Exception(\\\"index exceeds max index of terms\\\")\\n else:\\n raise NotImplementedError(\\\"currently only last term can be removed\\\")\\n pass\\n self._rebuild_indicator()\\n self.clear_cache('Fstar','Astar','Xstar','Xhat',\\n 'Areml','Areml_eigh','Areml_chol','Areml_inv','beta_hat','B_hat',\\n 'LRLdiag_Xhat_tens','Areml_grad',\\n 'beta_grad','Xstar_beta_grad','Zstar','DLZ')\",\n \"def addObjFxnTerm(model, A, x, b, wt, n_aux, name, lb=0):\\n import gurobipy as gb\\n Ax = model.addMVar(n_aux, vtype=gb.GRB.CONTINUOUS, lb=lb, name=name)\\n model.addConstr(A @ x == Ax, name=f\\\"{name}_cons\\\") # Constrain the Ax auxiliary variable to be equal to query answer\\n #return wt * (Ax @ Ax - 2 * b @ Ax) # Quadratic obj_fxn terms for query answers: wt * (Ax - b)^2, constant dropped\\n return (Ax @ wt @ Ax - 2 * b @ wt @ Ax) # Quadratic obj_fxn terms for query answers: wt * (Ax - b)^2, constant dropped\",\n \"def buildWPriorTerm(self):\\r\\n\\r\\n # self.w_prior.shape == (minibatch size,)\\r\\n self.w_prior = 0.5*T.sum(1 + T.log(self.qwgy_var) - self.qwgy_mu**2-self.qwgy_var, axis=1)\\r\\n\\r\\n self.w_prior_modif = - T.maximum(self.hyper['treshold_w_prior'], -self.w_prior)\",\n \"def reset_hessian_and_bias(self):\\n # reset_shared_var(self.t_H)\\n t = self.QUAD_REG\\n if len(t.shape) == 1:\\n self.t_H.set_value(np.diag(self.QUAD_REG))\\n elif len(t.shape) == 2:\\n self.t_H.set_value(self.QUAD_REG)\\n else:\\n raise ValueError('Invalid quad_reg shape')\\n\\n reset_shared_var(self.t_B)\",\n \"def _initialize_bounds(problem, bounds, get_bound, set_bound):\\n for constraint in problem.constraints:\\n root_expr = constraint.root_expr\\n expr_bounds = Interval(constraint.lower_bound, constraint.upper_bound)\\n if root_expr not in bounds:\\n set_bound(root_expr, expr_bounds)\\n else:\\n existing_bounds = get_bound(root_expr)\\n new_bounds = existing_bounds.intersect(expr_bounds)\\n set_bound(root_expr, new_bounds)\",\n \"def forces(self):\\n pass\",\n \"def epflux_eddyterms():\\n pass\",\n \"def preprocess(self):\\n\\n if self.x_range == None:\\n x_min = min(np.min(self.fx), np.min(self.gx))\\n x_max = max(np.max(self.fx), np.max(self.gx))\\n self.x_range = [x_min,x_max]\\n\\n f_inter = interpolate.interp1d(self.fx, self.fy, 'cubic', fill_value = 'extrapolate')\\n g_inter = interpolate.interp1d(self.gx, self.gy, 'cubic', fill_value = 'extrapolate')\\n fgx_new = np.linspace(self.x_range[0], self.x_range[1], self.N)\\n fy_new = f_inter(fgx_new)\\n gy_new = g_inter(fgx_new)\\n\\n self.fx, self.fy = fgx_new, fy_new\\n self.gx, self.gy = fgx_new, gy_new\",\n \"def calc(self):\\n\\n # the following if query ensures that volume- and interaction-terms\\n # are only calculated if tau > 0.\\n # (to avoid nan-values from invalid function-evaluations)\\n\\n if self.V.tau.shape == (1,):\\n Isurf = self.surface()\\n # differentiation for non-existing canopy, as otherwise NAN values\\n if self.V.tau > 0.:\\n Ivol = self.volume()\\n if self.int_Q is True:\\n Iint = self.interaction()\\n else:\\n Iint = np.array([0.])\\n else:\\n Ivol = np.array([0.])\\n Iint = np.array([0.])\\n else:\\n # calculate surface-term (valid for any tau-value)\\n Isurf = self.surface()\\n\\n # store initial parameter-values\\n old_t_0 = self.t_0\\n old_p_0 = self.p_0\\n old_t_ex = self.t_ex\\n old_p_ex = self.p_ex\\n\\n old_tau = self.V._get_tau()\\n old_omega = self.V._get_omega()\\n old_NN = self.SRF._get_NormBRDF()\\n\\n # set mask for tau > 0.\\n mask = old_tau > 0.\\n valid_index = np.where(mask)\\n inval_index = np.where(~mask)\\n\\n # set parameter-values to valid values for calculation\\n self.t_0 = old_t_0[valid_index[0]]\\n self.p_0 = old_p_0[valid_index[0]]\\n self.t_ex = old_t_ex[valid_index[0]]\\n self.p_ex = old_p_ex[valid_index[0]]\\n\\n # squeezing the arrays is necessary since the setter-function for\\n # tau, omega and NormBRDF automatically adds an axis to the arrays!\\n self.V.tau = np.squeeze(old_tau[valid_index[0]])\\n if np.array(self.V.omega).size != 1:\\n self.V.omega = np.squeeze(old_omega[valid_index[0]])\\n if np.array(self.SRF.NormBRDF).size != 1:\\n self.SRF.NormBRDF = np.squeeze(old_NN[valid_index[0]])\\n\\n # calculate volume and interaction term where tau-values are valid\\n _Ivol = self.volume()\\n if self.int_Q is True:\\n _Iint = self.interaction()\\n else:\\n _Iint = np.full_like(self.t_0, 0.)\\n\\n # reset parameter values to old values\\n self.t_0 = old_t_0\\n self.p_0 = old_p_0\\n self.t_ex = old_t_ex\\n self.p_ex = old_p_ex\\n\\n # squeezing the arrays is necessary since the setter-function for\\n # tau, omega and NormBRDF automatically add an axis to the arrays!\\n self.V.tau = np.squeeze(old_tau)\\n self.V.omega = np.squeeze(old_omega)\\n self.SRF.NormBRDF = np.squeeze(old_NN)\\n\\n # combine calculated volume-contributions for valid tau-values\\n # with zero-arrays for invalid tau-values\\n Ivol = np.ones_like(self.t_0)\\n Ivol[valid_index[0]] = _Ivol\\n Ivol[inval_index[0]] = np.ones_like(Ivol[inval_index[0]]) * 0.\\n\\n # combine calculated interaction-contributions for valid tau-values\\n # with zero-arrays for invalid tau-values\\n if self.int_Q is True:\\n Iint = np.ones_like(self.t_0)\\n Iint[valid_index[0]] = _Iint\\n Iint[inval_index[0]] = np.ones_like(Iint[inval_index[0]]) * 0.\\n else:\\n Iint = np.full_like(self.t_0, 0.)\\n\\n return Isurf + Ivol + Iint, Isurf, Ivol, Iint\",\n \"def _redef_sp1_vars(self):\\r\\n\\r\\n if len(self.fq_list) == 0:\\r\\n no_rad = True\\r\\n lst_tmp = np.matrix(np.reshape(self.lst_tmp, \\r\\n (self.lst_tmp.size, 1)))\\r\\n else: no_rad = False\\r\\n # The practically constants...\\r\\n # Big Epsilon:\\r\\n if self.cond == True:\\r\\n self.Epsilon = self.d_T * self.thermal_conductivity\\r\\n else:\\r\\n self.Epsilon = (self.diff_scale ** 2) / \\\\\\r\\n (3.0 * self.absorb_coeffs[self.rad] ** 2)\\r\\n # Beta:\\r\\n if self.cond == True:\\r\\n self.Beta = (self.diff_scale * self.thermal_conductivity) / \\\\\\r\\n (self.convect_coeff)\\r\\n else:\\r\\n self.Beta = (1.0 + 3.0 * self.r2) * (2.0 * self.diff_scale) / \\\\\\r\\n ((1.0 - 2.0 * self.r1) * (\\r\\n 3.0 * self.absorb_coeffs[self.rad]))\\r\\n\\r\\n # The feild solutions at the last timestep.\\r\\n # The integral vF:\\r\\n if self.cond == True:\\r\\n # The horrifically complicated F:\\r\\n def F_func_cond(elem, eta):\\r\\n F = 0.0\\r\\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n F += Tn\\r\\n for k in range(0, len(self.fq_list)):\\r\\n vk = self.fq_list[k]\\r\\n try:\\r\\n vk_m = self.fq_list[k - 1]\\r\\n except:\\r\\n vk_m = self.v0_frequency\\r\\n absorbtion = self.absorb_coeffs[k]\\r\\n phi = elem.eval_elem(self.node_map, self.lst_rad[k],\\r\\n [eta])[0]\\r\\n inter1 = phi - 4.0 * sconst.pi * \\\\\\r\\n self.B_int_function(Tn, self.refr_idx_vol,\\r\\n vk, vk_m)\\r\\n inter2 = absorbtion * self.d_T / (self.diff_scale ** 2)\\r\\n F += inter2 * inter1\\r\\n return elem.funcs(eta) * F\\r\\n if not no_rad:\\r\\n # We're integrating something non-linear for SP1\\r\\n self.vF_vect_vol = et.elems_2_array(self.mesh,\\r\\n F_func_cond,\\r\\n self.node_map)\\r\\n else:\\r\\n # Or something easier if we're only looking at heat.\\r\\n self.vF_vect_vol = np.array(self.uv_vol * lst_tmp).reshape(-1)\\r\\n else:\\r\\n def F_func_radiative(elem, eta):\\r\\n T = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n vk = self.fq_list[self.rad]\\r\\n try:\\r\\n vk_minus = self.fq_list[self.rad - 1]\\r\\n except:\\r\\n vk_minus = self.v0_frequency\\r\\n n = self.refr_idx_vol\\r\\n F = 4.0 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\\r\\n return elem.funcs(eta) * F\\r\\n\\r\\n self.vF_vect_vol = et.elems_2_array(self.mesh,\\r\\n F_func_radiative,\\r\\n self.node_map)\\r\\n # The path integral vf:\\r\\n if self.cond == True:\\r\\n def f_func_cond(elem, eta):\\r\\n Tb = self.background_temperature\\r\\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n n = self.refr_idx_background\\r\\n vk = self.v0_frequency\\r\\n vk_minus = 0\\r\\n Bb0 = self.B_int_function(Tb, n, vk, vk_minus)\\r\\n Bn0 = self.B_int_function(Tn, n, vk, vk_minus)\\r\\n B_coeff = (self.alpha * sconst.pi) / self.convect_coeff\\r\\n f = Tb + B_coeff * (Bb0 - Bn0)\\r\\n return elem.funcs(eta) * f\\r\\n if not no_rad:\\r\\n self.vf_vect_bound = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n f_func_cond,\\r\\n self.node_map)\\r\\n else:\\r\\n try:\\r\\n self.vf_vect_bound = self.cache_tb_integral_array\\r\\n except AttributeError:\\r\\n def elem_functor(elem, eta): return elem.funcs(eta)\\r\\n self.cache_tb_integral_array = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n elem_functor,\\r\\n self.node_map)\\r\\n self.cache_tb_integral_array *= self.background_temperature\\r\\n self.vf_vect_bound = self.cache_tb_integral_array\\r\\n \\r\\n else:\\r\\n # Radiation f = 4*pi*B^{(k)}(T_b, n_g)\\r\\n def f_func_radiative(elem, eta):\\r\\n T = self.background_temperature\\r\\n vk = self.fq_list[self.rad]\\r\\n try:\\r\\n vk_minus = self.fq_list[self.rad - 1]\\r\\n except:\\r\\n vk_minus = self.v0_frequency\\r\\n n = self.refr_idx_vol\\r\\n f = 4 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\\r\\n return elem.funcs(eta) * f\\r\\n\\r\\n self.vf_vect_bound = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n f_func_radiative,\\r\\n self.node_map)\\r\\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\\r\\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\\r\\n assert (self.vf_vect_bound.shape[0] == \\\\\\r\\n self.vF_vect_vol.shape[0])\",\n \"def eventually(self, t1, t2):\\n new_robustness = lambda s, t : max([ self.robustness(s,k) for k in range(t+t1, t+t2+1)])\\n\\n new_formula = STLFormula(new_robustness)\\n\\n return new_formula\",\n \"def _manage_infinity_bounds(problem, _bounds, get_bound, set_bound):\\n for variable in problem.variables:\\n expr_bounds = get_bound(variable)\\n lower_bound = expr_bounds.lower_bound\\n upper_bound = expr_bounds.upper_bound\\n\\n if is_inf(lower_bound):\\n new_lower_bound = None\\n else:\\n new_lower_bound = lower_bound\\n\\n if is_inf(upper_bound):\\n new_upper_bound = None\\n else:\\n new_upper_bound = upper_bound\\n\\n set_bound(variable, Interval(new_lower_bound, new_upper_bound))\",\n \"def calculateExteriorElementBoundaryQuadrature(self):\\n #\\n #get physical locations of element boundary quadrature points\\n #\\n #assume all components live on the same mesh\\n self.u[0].femSpace.elementMaps.getValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\\n self.ebqe['x'])\\n #\\n #get metric tensor and unit normals\\n #\\n if self.movingDomain:\\n if self.tLast_mesh != None:\\n self.ebqe['xt'][:]=self.ebqe['x']\\n self.ebqe['xt']-=self.ebqe['x_last']\\n alpha = 1.0/(self.t_mesh - self.tLast_mesh)\\n self.ebqe['xt']*=alpha\\n else:\\n self.ebqe['xt'][:]=0.0\\n self.ebqe['x_last'][:]=self.ebqe['x']\\n self.u[0].femSpace.elementMaps.getJacobianValuesGlobalExteriorTrace_movingDomain(self.elementBoundaryQuadraturePoints,\\n self.ebqe['xt'],\\n self.ebqe['inverse(J)'],\\n self.ebqe['g'],\\n self.ebqe['sqrt(det(g))'],\\n self.ebqe['n'])\\n else:\\n self.u[0].femSpace.elementMaps.getJacobianValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\\n self.ebqe['inverse(J)'],\\n self.ebqe['g'],\\n self.ebqe['sqrt(det(g))'],\\n self.ebqe['n'])\\n #now map the physical points back to the reference element\\n #assume all components live on same mesh\\n self.u[0].femSpace.elementMaps.getInverseValuesGlobalExteriorTrace(self.ebqe['inverse(J)'],self.ebqe['x'],self.ebqe['hat(x)'])\\n #\\n #since the points on the reference boundary may be reordered on many right element boundaries, we\\n #have to use an array of reference boundary points on all element boundaries\\n #first copy the left reference element boundary quadrature points from the reference element boundary\\n self.testSpace[0].getBasisValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\\n self.ebqe[('w',0)])\\n cfemIntegrals.calculateWeightedShapeGlobalExteriorTrace(self.mesh.exteriorElementBoundariesArray,\\n self.mesh.elementBoundaryElementsArray,\\n self.mesh.elementBoundaryLocalElementBoundariesArray,\\n self.elementBoundaryQuadratureWeights[('f',0)],\\n self.ebqe['sqrt(det(g))'],\\n self.ebqe[('w',0)],\\n self.ebqe[('w*dS_f',0)])\\n self.u[0].femSpace.getBasisGradientValuesGlobalExteriorTrace(self.elementBoundaryQuadraturePoints,\\n self.ebqe['inverse(J)'],\\n self.ebqe[('grad(v)',0)])\\n #setup flux boundary conditions\\n self.fluxBoundaryConditionsObjectsDict = dict([(cj,FluxBoundaryConditions(self.mesh,\\n self.nElementBoundaryQuadraturePoints_elementBoundary,\\n self.ebqe[('x')],\\n self.advectiveFluxBoundaryConditionsSetterDict[cj],\\n self.diffusiveFluxBoundaryConditionsSetterDictDict[cj]))\\n for cj in self.advectiveFluxBoundaryConditionsSetterDict.keys()])\\n self.ebqe['dS'] = numpy.zeros((self.mesh.nExteriorElementBoundaries_global,self.nElementBoundaryQuadraturePoints_elementBoundary),'d')\\n cfemIntegrals.calculateIntegrationWeights(self.ebqe['sqrt(det(g))'],\\n self.elementBoundaryQuadratureWeights[('u',0)],\\n self.ebqe['dS'])\\n for ci in range(self.nc): self.ebqe[('dS',ci)] = self.ebqe['dS']\\n #\\n self.ellamDiscretization.calculateExteriorElementBoundaryQuadrature(self.ebqe)\\n #\\n self.coefficients.initializeGlobalExteriorElementBoundaryQuadrature(self.timeIntegration.t,self.ebqe)\",\n \"def R_term(\\n enst, # enstrophy field\\n omega1, # vorticity-1 component\\n omega2, # vorticity-2 component\\n omega3, # vorticity-3 component\\n s11, # strain rate-11 component\\n s12, # strain rate-12 component\\n s13, # strain rate-13 component\\n s22, # strain rate-22 component\\n s23, # strain rate-23 component\\n s33, # strain rate-33 component\\n diff = False): # differentiation flag\\n #---------------------------------------------------------------------#\\n # Defining domain variables #\\n #---------------------------------------------------------------------#\\n pi = np.pi # pi\\n dx = (2.0*pi)/64.0 # spatial step\\n nu = 0.000185 # default viscosity\\n #---------------------------------------------------------------------#\\n # Spectral differentiation variables #\\n #---------------------------------------------------------------------#\\n dim = 64\\n kspec = np.fft.fftfreq(dim) * dim\\n Kfield = np.array(np.meshgrid(kspec, kspec, kspec, indexing='ij'))\\n #---------------------------------------------------------------------#\\n # Spectral differentiation variables #\\n #---------------------------------------------------------------------#\\n term1 = np.zeros((dim, dim, dim))\\n term2 = np.zeros((dim, dim, dim))\\n term3 = np.zeros((dim, dim, dim))\\n #---------------------------------------------------------------------#\\n # Numerator (numpy gradient tool) #\\n #---------------------------------------------------------------------#\\n if diff is not False:\\n term1 = np.gradient(enst,dx, edge_order=2)[0]\\n term2 = np.gradient(enst,dx, edge_order=2)[1]\\n term3 = np.gradient(enst,dx, edge_order=2)[2]\\n #---------------------------------------------------------------------#\\n # Numerator (spectral differentiation) #\\n #---------------------------------------------------------------------#\\n else:\\n term1 = 0.5*np.fft.ifftn(1j*Kfield[0]*np.fft.fftn(enst) +\\\\\\n 1j*Kfield[0]*np.fft.fftn(enst)).real\\n term2 = 0.5*np.fft.ifftn(1j*Kfield[1]*np.fft.fftn(enst) +\\\\\\n 1j*Kfield[1]*np.fft.fftn(enst)).real\\n term3 = 0.5*np.fft.ifftn(1j*Kfield[2]*np.fft.fftn(enst) +\\\\\\n 1j*Kfield[2]*np.fft.fftn(enst)).real\\n #---------------------------------------------------------------------#\\n # Numerator #\\n #---------------------------------------------------------------------#\\n num = nu*(term1**2.0+ term2**2.0 + term3**2.0)\\n #---------------------------------------------------------------------#\\n # Denominator #\\n #---------------------------------------------------------------------#\\n den = omega1*s11*omega1 + omega1*s12*omega2 + omega1*s13*omega3 +\\\\\\n omega2*s12*omega1 + omega2*s22*omega2 + omega2*s23*omega3+\\\\\\n omega3*s13*omega1 + omega3*s23*omega2 + omega3*s33*omega3\\n #---------------------------------------------------------------------#\\n # R calculation #\\n #---------------------------------------------------------------------#\\n R = num/den\\n\\n return R\",\n \"def update_boundary(self):\\n\\n cell = self._fire_boundary.dequeue()\\n neighbors = self.four_neighbors(cell[0], cell[1])\\n #neighbors = self.eight_neighbors(cell[0], cell[1])\\n for neighbor in neighbors:\\n if self.is_empty(neighbor[0], neighbor[1]):\\n self.set_full(neighbor[0], neighbor[1])\\n self._fire_boundary.enqueue(neighbor)\\n\\n # Check class invariant after update\\n assert self.boundary_invariant()\",\n \"def do(self, variables, values):\\n intervened = LinearGaussianBN()\\n sym_values = [Symbol(val) if isinstance(val, str) else val for val in values]\\n var_to_value = dict(zip(variables, sym_values))\\n for variable in self.variables:\\n if variable not in variables:\\n new_parents = []\\n new_weights = [self._weights[variable][0]]\\n for indx, p in enumerate(self.parents(variable)):\\n w = self._weights[variable][indx + 1]\\n if p not in variables:\\n new_parents.append(p)\\n new_weights.append(w)\\n else:\\n new_weights[0] += w * var_to_value[p]\\n\\n intervened.add_var(variable, new_parents, new_weights)\\n\\n return intervened\",\n \"def SetPRCatConstraint(self, model ) :\\n tot = np.multiply(self.wish, self.dispo)\\n for line in tot :\\n for val in line :\\n if not val : continue\\n if self.bound>0 : model += val <= self.valBound\\n elif self.bound<0 : model += val >= self.valBound\",\n \"def terms(self, terms):\\n\\n self._terms = terms\",\n \"def set_weight(term, irrelevant):\\n if term in irrelevant:\\n return (0.2 * max([x/sum(indtf_features[term]) for x in indtf_features[term]]))\\n elif isinstance(term, tuple):\\n return len(term)\\n else:\\n return 1\",\n \"def _compute_forces(self):\\n # get new coeffs\\n self._get_coeffs()\\n\\n # instead of writing many time\\n awa = self.awa / 180.0 * np.pi\\n\\n # lift and drag\\n self.lift = 0.5 * self.rho * self.aws ** 2 * self.area * self.cl\\n self.drag = 0.5 * self.rho * self.aws ** 2 * self.area * self.cd + self._get_Rw(awa)\\n\\n # project into yacht coordinate system\\n self.Fx = self.lift * np.sin(awa) - self.drag * np.cos(awa)\\n self.Fy = self.lift * np.cos(awa) + self.drag * np.sin(awa)\\n\\n # heeling moment\\n self.Mx = self.Fy * self._vce() * np.cos(self.phi / 180.0 * np.pi)\\n\\n # side-force is horizontal component of Fh\\n self.Fy *= np.cos(np.deg2rad(self.phi))\",\n \"def initialize_constants(self):\\n # maximum pheromone value\\n self.PH_MAX = np.float_( len(self.variables) / (1.0 - self.PH_REDUCE_FACTOR))\\n # minimum pheromone value\\n self.PH_MIN = np.float_(self.PH_MAX / (2*len(self.variables)) )\",\n \"def _solve_freq_rb(self, d, v, a, force, freqw, freqw2, incrb, unc):\\n if self.rbsize and incrb:\\n rb = self.rb\\n if self.m is not None:\\n if unc:\\n a_rb = self.invm[self._rb] * force[rb]\\n else:\\n a_rb = la.lu_solve(self.imrb, force[rb], check_finite=False)\\n else:\\n a_rb = force[rb]\\n if \\\"d\\\" in incrb or \\\"v\\\" in incrb:\\n pvnz = freqw != 0\\n if \\\"v\\\" in incrb:\\n v[rb, pvnz] = (-1j / freqw[pvnz]) * a_rb[:, pvnz]\\n if \\\"d\\\" in incrb:\\n d[rb, pvnz] = (-1.0 / freqw2[pvnz]) * a_rb[:, pvnz]\\n if \\\"a\\\" in incrb:\\n a[rb] = a_rb\",\n \"def test_basic_handling_range_with_variable_bounds(spark_ctx):\\n\\n dr = Drudge(spark_ctx)\\n\\n j1, j2 = symbols('j1 j2')\\n m1, m2 = symbols('m1, m2')\\n j_max = symbols('j_max')\\n j = Range('j', 0, j_max)\\n m = Range('m')\\n dr.set_dumms(j, [j1, j2])\\n dr.set_dumms(m, [m1, m2])\\n\\n v = Vec('v')\\n x = IndexedBase('x')\\n tensor = dr.sum((j2, j), (m2, m[0, j2]), x[j2, m2] * v[j2, m2])\\n\\n reset = tensor.reset_dumms()\\n assert reset.n_terms == 1\\n term = reset.local_terms[0]\\n assert len(term.sums) == 2\\n if term.sums[0][1].label == 'j':\\n j_sum, m_sum = term.sums\\n else:\\n m_sum, j_sum = term.sums\\n assert j_sum[0] == j1\\n assert j_sum[1].args == j.args\\n assert m_sum[0] == m1\\n assert m_sum[1].label == 'm'\\n assert m_sum[1].lower == 0\\n assert m_sum[1].upper == j1 # Important!\\n assert term.amp == x[j1, m1]\\n assert term.vecs == (v[j1, m1],)\\n\\n # Test that functions can be mapped to the bounds.\\n repled = reset.map2scalars(\\n lambda x: x.xreplace({j_max: 10}), skip_ranges=False\\n )\\n assert repled.n_terms == 1\\n term = repled.local_terms[0]\\n checked = False\\n for _, i in term.sums:\\n if i.label == 'j':\\n assert i.lower == 0\\n assert i.upper == 10\\n checked = True\\n continue\\n assert checked\",\n \"def force ( r, e ):\\n from math import isclose\\n\\n # Parameters of the Gay-Berne potential \\n # \\n # The key parameters are \\n # mu, nu ................ the exponents \\n # kappa and kappa' ....... the anisotropies \\n # kappa is the ratio of intermolecular separations \\n # sigma_e / sigma_s i.e. end-to-end / side-by-side \\n # kappa' is the ratio of well depths \\n # epsilon_s / epsilon_e i.e. side-by-side / end-to-end \\n # The derived parameters are chi and chi' \\n # chi = (kappa**2 - 1) / (kappa**2+1) \\n # chi' = (z - 1) / (z + 1)\\n # where z = (kappa') ** ( 1 / mu ) \\n # \\n # For convenience kappa' is spelt xappa, chi' is spelt xhi\\n # We choose units such that sigma_s = 1.0 and epsilon_0 = 1.0\\n # Two of the following three varieties should be commented out\\n\\n # Original Gay-Berne-deMiguel potential [J. Chem. Phys, 74, 3316; Mol. Phys. 74, 405 (1991)]\\n mu, nu, kappa, xappa = 2, 1, 3.0, 5.0\\n\\n # # Luckhurst-Phippen potential [Liq. Cryst., 8, 451 (1990)]\\n # mu, nu, kappa, xappa = 1, 2, 3.0, 5.0\\n\\n # # Berardi-Zannoni potential [J. Chem. Soc. Faraday Trans., 89, 4069 (1993)]\\n # mu, nu, kappa, xappa = 1, 3, 3.0, 5.0\\n\\n # Derived parameters\\n chi = (kappa**2 - 1.0) / (kappa**2+1.0)\\n xhi = (xappa**(1.0/mu) - 1.0) / (xappa**(1.0/mu) + 1.0)\\n\\n # Cutoff distance; normally we would use a larger value\\n r_cut = 4.0\\n \\n assert r.shape == (n,3), 'Incorrect shape of r'\\n assert e.shape == (n,3), 'Incorrect shape of e'\\n\\n # Notation to match appendix\\n i = 0\\n j = 1\\n\\n ei = e[i,:]\\n ej = e[j,:]\\n assert isclose(np.sum(ei**2),1.0), 'Non-unit vector {} {} {}'.format(*ei)\\n assert isclose(np.sum(ej**2),1.0), 'Non-unit vector {} {} {}'.format(*ej)\\n\\n rij = r[i,:] - r[j,:]\\n rij_mag = np.sqrt( np.sum(rij**2) ) # Magnitude of separation vector\\n sij = rij / rij_mag # Unit vector\\n ci = np.dot( ei, sij )\\n cj = np.dot( ej, sij )\\n cij = np.dot( ei, ej )\\n cp = ci + cj\\n cm = ci - cj\\n\\n # Sigma formula\\n cpchi = cp/(1.0+chi*cij)\\n cmchi = cm/(1.0-chi*cij)\\n sigma = 1.0/np.sqrt(1.0-0.5*chi*(cp*cpchi+cm*cmchi))\\n\\n # Epsilon formula\\n eps1 = 1.0/np.sqrt(1.0-(chi*cij)**2) # Depends on chi, not xhi\\n cpxhi = cp/(1.0+xhi*cij)\\n cmxhi = cm/(1.0-xhi*cij)\\n eps2 = 1.0-0.5*xhi*(cp*cpxhi+cm*cmxhi) # Depends on xhi\\n epsilon = (eps1**nu) * (eps2**mu)\\n\\n # Potential at rij\\n rho = rij_mag - sigma + 1.0\\n rho6 = 1.0 / rho**6\\n rho12 = rho6**2\\n rhoterm = 4.0*(rho12 - rho6) # Needed for forces and torques\\n drhoterm = -24.0 * (2.0 * rho12 - rho6) / rho # Needed for forces and torques\\n pot = epsilon*rhoterm\\n\\n # Potential at r_cut\\n rho = r_cut - sigma + 1.0\\n rho6 = 1.0 / rho**6\\n rho12 = rho6**2\\n cutterm = 4.0*(rho12 - rho6) # Needed for cutoff forces and torques\\n dcutterm = -24.0 * (2.0 * rho12 - rho6) / rho # Needed for cutoff forces and torques\\n pot = pot - epsilon * cutterm\\n\\n # Derivatives of sigma\\n prefac = 0.5*chi*sigma**3\\n dsig_dci = prefac*(cpchi+cmchi)\\n dsig_dcj = prefac*(cpchi-cmchi)\\n prefac = prefac*(0.5*chi)\\n dsig_dcij = -prefac*(cpchi**2-cmchi**2)\\n\\n # Derivatives of epsilon\\n prefac = -mu*xhi*(eps1**nu)*eps2**(mu-1)\\n deps_dci = prefac*(cpxhi+cmxhi)\\n deps_dcj = prefac*(cpxhi-cmxhi)\\n prefac = prefac*(0.5*xhi)\\n deps_dcij = -prefac*(cpxhi**2-cmxhi**2) # From derivative of eps2\\n deps_dcij = deps_dcij + nu*(chi**2)*(eps1**(nu+2))*(eps2**mu)*cij # From derivative of eps1\\n\\n # Derivatives of potential\\n dpot_drij = epsilon * drhoterm\\n dpot_dci = rhoterm * deps_dci - epsilon * drhoterm * dsig_dci\\n dpot_dcj = rhoterm * deps_dcj - epsilon * drhoterm * dsig_dcj\\n dpot_dcij = rhoterm * deps_dcij - epsilon * drhoterm * dsig_dcij\\n\\n # Standard formula for forces and torque gradients\\n fij = -dpot_drij*sij - dpot_dci*(ei-ci*sij)/rij_mag - dpot_dcj*(ej-cj*sij)/rij_mag\\n gi = dpot_dci*sij + dpot_dcij*ej\\n gj = dpot_dcj*sij + dpot_dcij*ei\\n\\n # Derivatives of potential at cutoff\\n dpot_drij = epsilon * dcutterm\\n dpot_dci = cutterm * deps_dci - epsilon * dcutterm * dsig_dci\\n dpot_dcj = cutterm * deps_dcj - epsilon * dcutterm * dsig_dcj\\n dpot_dcij = cutterm * deps_dcij - epsilon * dcutterm * dsig_dcij\\n\\n # Standard formula for forces and torque gradients (without dpot_drij term)\\n fij = fij + dpot_dci*(ei-ci*sij)/rij_mag + dpot_dcj*(ej-cj*sij)/rij_mag\\n gi = gi - ( dpot_dci*sij + dpot_dcij*ej ) \\n gj = gj - ( dpot_dcj*sij + dpot_dcij*ei ) \\n\\n # Final forces and torques\\n f = np.empty_like(r)\\n t = np.empty_like(r)\\n f[i,:] = fij\\n f[j,:] = -fij\\n t[i,:] = -np.cross(ei,gi)\\n t[j,:] = -np.cross(ej,gj)\\n\\n return pot, f, t\",\n \"def wang(G, term1, term2):\\n if term1 not in G or term2 not in G:\\n return 0\\n sa = s_values(G, term1)\\n sb = s_values(G, term2)\\n sva = sum(sa.values())\\n svb = sum(sb.values())\\n common = set(sa.keys()) & set(sb.keys())\\n cv = sum(sa[c] + sb[c] for c in common)\\n return round(cv / (sva + svb), 3)\",\n \"def calculate_boundaries(self, latmesh=False, mask=None, lat_mask=None,\\n adot=None, U_mask=None, mark_divide=False):\\n s = \\\"::: calculating boundaries :::\\\"\\n print_text(s, cls=self)\\n\\n if lat_mask == None and mark_divide:\\n s = \\\">>> IF PARAMETER <mark_divide> OF calculate_boundaries() IS \\\" + \\\\\\n \\\"TRUE, PARAMETER <lat_mask> MUST BE AN EXPRESSION FOR THE LATERAL\\\" + \\\\\\n \\\" BOUNDARIES <<<\\\"\\n print_text(s, 'red', 1)\\n sys.exit(1)\\n \\n # this function contains markers which may be applied to facets of the mesh\\n self.ff = FacetFunction('size_t', self.mesh)\\n self.ff_acc = FacetFunction('size_t', self.mesh)\\n self.cf = CellFunction('size_t', self.mesh)\\n dofmap = self.Q.dofmap()\\n\\n S = self.S\\n B = self.B\\n \\n # default to all grounded ice :\\n if mask == None:\\n mask = Expression('1.0', element=self.Q.ufl_element())\\n \\n # default to all positive accumulation :\\n if adot == None:\\n adot = Expression('1.0', element=self.Q.ufl_element())\\n \\n # default to U observations everywhere :\\n if U_mask == None:\\n U_mask = Expression('1.0', element=self.Q.ufl_element())\\n\\n self.init_adot(adot)\\n self.init_mask(mask)\\n self.init_U_mask(U_mask)\\n\\n if mark_divide:\\n s = \\\" - marking the interior facets for incomplete meshes -\\\"\\n print_text(s, cls=self)\\n self.init_lat_mask(lat_mask)\\n\\n self.S.set_allow_extrapolation(True)\\n self.B.set_allow_extrapolation(True)\\n self.mask.set_allow_extrapolation(True)\\n self.adot.set_allow_extrapolation(True)\\n self.U_mask.set_allow_extrapolation(True)\\n self.lat_mask.set_allow_extrapolation(True)\\n \\n tol = 1e-6\\n \\n s = \\\" - marking boundaries - \\\"\\n print_text(s, cls=self)\\n\\n if latmesh:\\n s = \\\" - using a lateral surface mesh - \\\"\\n print_text(s, cls=self)\\n \\n class GAMMA_S_GND(SubDomain):\\n def inside(self, x, on_boundary):\\n return mask(x[0], x[1], x[2]) <= 1.0 and on_boundary\\n gamma_s_gnd = GAMMA_S_GND()\\n\\n class GAMMA_S_FLT(SubDomain):\\n def inside(self, x, on_boundary):\\n return mask(x[0], x[1], x[2]) > 1.0 and on_boundary\\n gamma_s_flt = GAMMA_S_FLT()\\n\\n class GAMMA_U_GND(SubDomain):\\n def inside(self, x, on_boundary):\\n return abs(x[2] - S(x[0], x[1], x[2])) < tol \\\\\\n and mask(x[0], x[1], x[2]) <= 1.0 \\\\\\n and U_mask(x[0], x[1], x[2]) <= 0.0 and on_boundary\\n gamma_u_gnd = GAMMA_U_GND()\\n\\n class GAMMA_U_FLT(SubDomain):\\n def inside(self, x, on_boundary):\\n return abs(x[2] - S(x[0], x[1], x[2])) < tol \\\\\\n and mask(x[0], x[1], x[2]) > 1.0 \\\\\\n and U_mask(x[0], x[1], x[2]) <= 0.0 and on_boundary\\n gamma_u_flt = GAMMA_U_FLT()\\n\\n class GAMMA_B_GND(SubDomain):\\n def inside(self, x, on_boundary):\\n return abs(x[2] - B(x[0], x[1], x[2])) < tol \\\\\\n and mask(x[0], x[1], x[2]) <= 1.0 and on_boundary\\n gamma_b_gnd = GAMMA_B_GND()\\n\\n class GAMMA_B_FLT(SubDomain):\\n def inside(self, x, on_boundary):\\n return abs(x[2] - B(x[0], x[1], x[2])) < tol \\\\\\n and mask(x[0], x[1], x[2]) > 1.0 and on_boundary\\n gamma_b_flt = GAMMA_B_FLT()\\n\\n class GAMMA_L_OVR(SubDomain):\\n def inside(self, x, on_boundary):\\n return x[2] > -10 and x[2] < S(x[0], x[1], x[2]) - tol and on_boundary\\n gamma_l_ovr = GAMMA_L_OVR()\\n\\n class GAMMA_L_UDR(SubDomain):\\n def inside(self, x, on_boundary):\\n return x[2] < 10 and x[2] < S(x[0], x[1], x[2]) - tol and on_boundary\\n gamma_l_udr = GAMMA_L_UDR()\\n\\n class GAMMA_L_TRM(SubDomain):\\n def inside(self, x, on_boundary):\\n return lat_mask(x[0], x[1], x[2]) <= 0.0\\n gamma_l_trm = GAMMA_L_TRM()\\n\\n gamma_s_flt.mark(self.ff, self.GAMMA_S_FLT)\\n gamma_s_gnd.mark(self.ff, self.GAMMA_S_GND)\\n gamma_l_ovr.mark(self.ff, self.GAMMA_L_OVR)\\n gamma_l_udr.mark(self.ff, self.GAMMA_L_UDR)\\n gamma_b_flt.mark(self.ff, self.GAMMA_B_FLT)\\n gamma_b_gnd.mark(self.ff, self.GAMMA_B_GND)\\n #gamma_u_flt.mark(self.ff, self.GAMMA_U_FLT)\\n #gamma_u_gnd.mark(self.ff, self.GAMMA_U_GND)\\n #if mark_divide: \\n # gamma_l_trm.mark(self.cf, 1)\\n \\n else :\\n s = \\\" - not using a lateral surface mesh - \\\"\\n print_text(s, cls=self)\\n\\n class GAMMA_GND(SubDomain):\\n def inside(self, x, on_boundary):\\n return mask(x[0], x[1], x[2]) <= 1.0\\n gamma_gnd = GAMMA_GND()\\n\\n class GAMMA_FLT(SubDomain):\\n def inside(self, x, on_boundary):\\n return mask(x[0], x[1], x[2]) > 1.0\\n gamma_flt = GAMMA_FLT()\\n\\n class GAMMA_L_OVR(SubDomain):\\n def inside(self, x, on_boundary):\\n return x[2] > -10 and on_boundary\\n gamma_l_ovr = GAMMA_L_OVR()\\n\\n class GAMMA_L_UDR(SubDomain):\\n def inside(self, x, on_boundary):\\n return x[2] < 10 and on_boundary\\n gamma_l_udr = GAMMA_L_UDR()\\n\\n gamma_flt.mark(self.cf, 1)\\n gamma_gnd.mark(self.cf, 0)\\n gamma_l_ovr.mark(self.ff, self.GAMMA_L_OVR)\\n gamma_l_udr.mark(self.ff, self.GAMMA_L_UDR)\\n \\n # mark the divide if desired : \\n if mark_divide:\\n class GAMMA_L_DVD(SubDomain):\\n def inside(self, x, on_boundary):\\n return lat_mask(x[0], x[1], x[2]) <= 0.0 and on_boundary\\n gamma_l_dvd = GAMMA_L_DVD()\\n gamma_l_dvd.mark(self.ff, self.GAMMA_L_DVD)\\n \\n s = \\\" - done - \\\"\\n print_text(s, cls=self)\\n \\n #s = \\\" - iterating through %i cells - \\\" % self.num_cells\\n #print_text(s, cls=self)\\n #for c in cells(self.mesh):\\n # x_m = c.midpoint().x()\\n # y_m = c.midpoint().y()\\n # z_m = c.midpoint().z()\\n # mask_xy = mask(x_m, y_m, z_m)\\n\\n # if mask_xy > 1:\\n # self.cf[c] = 1\\n # else:\\n # self.cf[c] = 0\\n\\n #s = \\\" - done - \\\"\\n #print_text(s, cls=self)\\n\\n self.ds = Measure('ds')[self.ff]\\n self.dx = Measure('dx')#[self.cf]\\n \\n self.dx_g = self.dx(0) # internal above grounded\\n self.dx_f = self.dx(1) # internal above floating\\n self.dBed_g = self.ds(3) # grounded bed\\n self.dBed_f = self.ds(5) # floating bed\\n self.dBed = self.ds(3) + self.ds(5) # bed\\n self.dSrf_gu = self.ds(8) # grounded with U observations\\n self.dSrf_fu = self.ds(9) # floating with U observations\\n self.dSrf_u = self.ds(8) + self.ds(9) # surface with U observations\\n self.dSrf_g = self.ds(2) + self.ds(8) # surface of grounded ice\\n self.dSrf_f = self.ds(6) + self.ds(9) # surface of floating ice\\n self.dSrf = self.ds(6) + self.ds(2) \\\\\\n + self.ds(8) + self.ds(9) # surface\\n self.dLat_d = self.ds(7) # lateral divide\\n self.dLat_to = self.ds(4) # lateral terminus overwater\\n self.dLat_tu = self.ds(10) # lateral terminus underwater\\n self.dLat_t = self.ds(4) + self.ds(10) # lateral terminus\\n self.dLat = self.ds(4) + self.ds(7) \\\\\\n + self.ds(10) # lateral\",\n \"def chgvarbound(self,j_,lower_,finite_,value_): # 3\\n res = self.__obj.chgvarbound(j_,lower_,finite_,value_)\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\",\n \"def add_bcs(self, RHS, bc_left, cff0 ,cff1, cff2):\\n RHS[0] += cff0 * self.c[0]/(2*self.dx)*bc_left\\n RHS[0] += cff1 * self.c[0]/(2*self.dx)*self.bcs[1]\\n RHS[0] += cff2 * self.c[0]/(2*self.dx)*self.bcs[2]\",\n \"def _para_boosting(self, H):\\n # print '----------------primal-dual boost-------------------'\\n H = np.hstack((H, -H))\\n # H_ft = np.asfortranarray((H.copy()))\\n (n, p) = H.shape\\n self.c = np.log(n*p)\\n nu = int(n * self.ratio)\\n\\n if self.max_iter < 50:\\n delta = 1\\n else:\\n delta = 40\\n d = np.ones(n) / n\\n d_bar = np.ones(n) / n\\n a_bar = np.ones(p) / p\\n a = np.ones(p) / p\\n h_a = np.sum(H, axis=1) / p\\n h_a_bar = h_a.copy()\\n # a_bar = a\\n # a_tilde = np.ones(p) / p\\n h_a_tilde = h_a.copy()\\n # d_tilde = np.zeros(p)\\n theta = 1\\n sig = 1\\n tau = 1\\n t = 0\\n logscale = 0\\n for t in range(self.max_iter):\\n d = prox_mapping(h_a_tilde, d, tau, 2)\\n if self.has_dcap:\\n d2 = proj_cap_ent(d, 1.0 / nu)\\n # d_new = d_new/d_new.sum()\\n if np.abs(d.sum() - d2.sum()) > 0.0001:\\n print 'error'\\n d = d2\\n d_tilde = d\\n dtH = np.dot(d_tilde, H)\\n # dtH = np.dot(H.T, d_tilde)\\n a_new = prox_mapping(-dtH, a, sig, 2)\\n h_a_new = np.dot(H, a_new)\\n # a_tilde = a_new + theta * (a_new - a)\\n h_a_tilde = (1+theta) * h_a_new - theta * h_a\\n a = a_new\\n h_a = h_a_new\\n d_bar *= t / (t + 1.0)\\n d_bar += 1.0 / (t + 1) * d\\n a_bar *= t / (t + 1.0)\\n a_bar += 1.0 / (t + 1) * a\\n # h_a_bar = np.dot(H, a_bar)\\n h_a_bar = t / (t + 1.0) * h_a_bar + 1.0/(t+1) * h_a\\n if int(np.log(t+1)) == logscale:\\n logscale += 1\\n self.iter_num.append(t)\\n if self.has_dcap:\\n min_margin = ksmallest2(h_a_bar, nu)\\n self.primal_obj.append(-np.mean(min_margin))\\n else:\\n self.primal_obj.append(- np.min(h_a_bar))\\n self.margin.append(-self.primal_obj[-1])\\n self.dual_obj.append(-np.max(np.dot(d_bar, H)))\\n self.gap.append(self.primal_obj[-1] - self.dual_obj[-1])\\n self.err_tr.append(np.mean(h_a_bar < 0))\\n # if t % 100 == 0:\\n # print 'iter ' + str(t) + ' ' + str(self.gap[-1])\\n if self.gap[-1] < self.epsi:\\n break\\n self.alpha = a_bar[:p / 2] - a_bar[p / 2:]\\n self.d = d_bar\\n print \\\" pd-boosting(python): max iter#%d: , actual iter#%d\\\" % (self.max_iter, t)\",\n \"def convergence_check(self):\\n air = self.air_alias.val\\n flue_gas = self.fuel_alias.val + '_fg'\\n fuel = self.fuel_alias.val\\n\\n for c in self.outl:\\n if not c.fluid.val_set[air]:\\n if c.fluid.val[air] > 0.95:\\n c.fluid.val[air] = 0.95\\n if c.fluid.val[air] < 0.5:\\n c.fluid.val[air] = 0.5\\n\\n if not c.fluid.val_set[flue_gas]:\\n if c.fluid.val[flue_gas] > 0.5:\\n c.fluid.val[flue_gas] = 0.5\\n if c.fluid.val[flue_gas] < 0.05:\\n c.fluid.val[flue_gas] = 0.05\\n\\n if not c.fluid.val_set[fuel]:\\n if c.fluid.val[fuel] > 0:\\n c.fluid.val[fuel] = 0\\n\\n c.target.propagate_fluid_to_target(c, c.target)\\n\\n for i in self.inl:\\n if i.m.val_SI < 0 and not i.m.val_set:\\n i.m.val_SI = 0.01\\n\\n for c in self.outl:\\n if c.m.val_SI < 0 and not c.m.val_set:\\n c.m.val_SI = 10\\n c.target.propagate_fluid_to_target(c, c.target)\\n\\n if self.lamb.val < 1 and not self.lamb.is_set:\\n self.lamb.val = 2\",\n \"def _add_unconformity_below(self, feature):\\n for f in self.features:\\n if f.type == 'series' and feature.feature.name != f.name:\\n f.add_region(lambda pos: ~feature.evaluate(pos))\\n # for f in reversed(self.features):\\n # if f.type == 'unconformity':\\n # feature.add_region(lambda pos: f.evaluate(pos))\\n # break\\n # feature.add_region(lambda pos: ~uc.evaluate(pos))\",\n \"def add_cp_qe_RBM_terms(K, cons_pot_mesh, quad_geo_mesh):\\n num_faces = cons_pot_mesh.get_faces().shape[0]\\n x_c = quad_geo_mesh.get_centroid()\\n w = quad_geo_mesh.get_w()\\n A_m = quad_geo_mesh.get_A_m()\\n S_D = quad_geo_mesh.get_surface_area()\\n\\n for face_num in range(num_faces):\\n face_nodes = quad_geo_mesh.get_tri_nodes(face_num)\\n face_hs = quad_geo_mesh.get_hs(face_num)\\n def v_quad(_xi, _eta, _nodes):\\n return np.identity(3)\\n v_sub_mat = (1. / S_D) * gq.int_over_tri_quad(v_quad, face_nodes, face_hs)\\n def omega_quad(xi, eta, nodes):\\n pos = geo.quadratic_interp(xi, eta, nodes)\\n X = pos - x_c\\n return np.einsum(\\\"lrs,s->lr\\\", geo.LC_3, X)\\n tmp_omega = gq.int_over_tri_quad(\\n omega_quad,\\n face_nodes,\\n face_hs,\\n )\\n tmp_arr = []\\n for m in range(3):\\n tmp_arr.append((1./ A_m[m]) * np.outer(w[m], np.einsum(\\\"l,ls\\\", w[m], tmp_omega)))\\n tmp_arr = np.array(tmp_arr)\\n tmp_omega_mat = np.sum(tmp_arr, axis=0)\\n for src_num in range(num_faces):\\n K[(3 * src_num):(3 * src_num + 3),\\n (3 * face_num):(3 * face_num + 3)] += v_sub_mat\\n src_center = cons_pot_mesh.get_node(src_num)\\n X_0 = src_center - x_c\\n omega_mat = np.einsum(\\\"ijk,js,k->is\\\", geo.LC_3, tmp_omega_mat, X_0)\\n K[(3 * src_num):(3 * src_num + 3),\\n (3 * face_num):(3 * face_num + 3)] += omega_mat\",\n \"def restrict(self):\\n\\n cg = self.grid.coarse_like(2)\\n\\n c_edge_coeffs = EdgeCoeffs(cg, None, empty=True)\\n\\n c_eta_x = cg.scratch_array()\\n c_eta_y = cg.scratch_array()\\n\\n fg = self.grid\\n\\n c_eta_x[cg.ilo:cg.ihi+2,cg.jlo:cg.jhi+1] = \\\\\\n 0.5*(self.x[fg.ilo:fg.ihi+2:2,fg.jlo :fg.jhi+1:2] +\\n self.x[fg.ilo:fg.ihi+2:2,fg.jlo+1:fg.jhi+1:2])\\n\\n # redo the normalization\\n c_edge_coeffs.x = c_eta_x*fg.dx**2/cg.dx**2\\n\\n c_eta_y[cg.ilo:cg.ihi+1,cg.jlo:cg.jhi+2] = \\\\\\n 0.5*(self.y[fg.ilo :fg.ihi+1:2,fg.jlo:fg.jhi+2:2] +\\n self.y[fg.ilo+1:fg.ihi+1:2,fg.jlo:fg.jhi+2:2])\\n\\n c_edge_coeffs.y = c_eta_y*fg.dy**2/cg.dy**2\\n\\n return c_edge_coeffs\",\n \"def _update_conformers(self, cutoff=0.002):\\n logger.debug(\\\"Updating conformers based on occupancy\\\")\\n\\n # Check that all arrays match dimensions.\\n assert len(self._occupancies) == len(self._coor_set) == len(self._bs)\\n\\n # Filter all arrays & lists based on self._occupancies\\n # NB: _coor_set and _bs are lists (not arrays). We must compress, not slice.\\n filterarray = self._occupancies >= cutoff\\n self._occupancies = self._occupancies[filterarray]\\n self._coor_set = list(itertools.compress(self._coor_set, filterarray))\\n self._bs = list(itertools.compress(self._bs, filterarray))\\n\\n logger.debug(f\\\"Remaining valid conformations: {len(self._coor_set)}\\\")\",\n \"def normalize_bounds(self, bounds):\\n scaled_bounds = []\\n scalings = []\\n intercepts = []\\n \\n non_fixed_params = []\\n \\n print(self.device)\\n \\n for name, domain in self.bounds.items():\\n # Get any fixed parmeters\\n if type(domain) == int or type(domain) == float:\\n # Take note\\n self.fixed_parameters.append(name)\\n\\n # Free parameters\\n elif type(domain) == tuple:\\n # Bookkeeping\\n self.free_parameters.append(name)\\n\\n # Get scaling\\n lower_bound = min(domain)\\n upper_bound = max(domain)\\n scale = upper_bound - lower_bound\\n\\n # Transform to [0, 1] domain\\n #scaled_bound = {'name': name, 'type': 'continuous', 'domain': (0., 1.)} #torch.adjustment required\\n non_fixed_params.append(name)\\n \\n # Store\\n #scaled_bounds.append(scaled_bound)\\n scalings.append(scale)\\n intercepts.append(lower_bound)\\n else:\\n raise ValueError(\\\"Domain bounds not understood\\\")\\n \\n n_hyperparams = len(non_fixed_params)\\n \\n scaled_bounds = cat([zeros(1,n_hyperparams, device = self.device), \\n ones(1, n_hyperparams, device = self.device)], 0)\\n return scaled_bounds, tensor(scalings, device = self.device, requires_grad = False), tensor(intercepts, device = self.device, requires_grad = False) #torch.adjustment required\",\n \"def always(self, t1, t2):\\n new_robustness = lambda s, t : min([ self.robustness(s,k) for k in range(t+t1, t+t2+1)])\\n\\n new_formula = STLFormula(new_robustness)\\n\\n return new_formula\",\n \"def _bowl_params(self):\\n self.vars['bowl_strength'] = self.bowl.strength + \\\\\\n self.vars['beta_min_offset']\\n self.vars['q_init'] = self.vars['bowl_strength']\\n if self.vars['bowl_strength'] <= self.vars['beta_min_offset']:\\n print(\\n f\\\"Bowl overflow -- Set to the minimum value : {self.vars['beta_min_offset']}\\\")\\n # raise ValueError(\\\"Bowl overflow... strength lower than set tolerance. Modify the tolerance or fix the bug!\\\")\\n self.vars['bowl_strength'] = self.vars['beta_min_offset']\\n if self.vars['bowl_strength'] > self.vars['q_max']:\\n self.vars['bowl_strength'] = self.vars['q_max']\\n\\n self.vars['zeta_bowl'] = self.toNeural(self.bowl.center)\\n print(f\\\"Value for Q set to {self.vars['bowl_strength']}\\\")\",\n \"def relax(self,n=1):\\n # print(\\\"putin\\\", self.level.rhs.reshape(-1)[:])\\n # print(\\\"getout\\\", self.solver(self.level.rhs.reshape(-1)))\\n for i in range(n):\\n self.level.mid[:] += (self.solver(self.level.rhs.reshape(-1)) -\\n self.solver(self.stencil.eval_convolve(\\n self.level.evaluable_view(self.stencil)).reshape(-1))).reshape(self.level.mid.shape)\",\n \"def compute_bounds(self):\\n # Note: linear_constraints object has been been populated at this stage\\n L_zero_var = []\\n \\n for constraint in self._linear_constraints.L_linear_constraints:\\n lhs_string = constraint[0]\\n rhs_string = constraint[1]\\n if float(rhs_string)==0:\\n #print \\\"rhs=0: forcing the variables to zero\\\"\\n L_vars = re.split(r'[+-]',lhs_string)\\n \\n for var in L_vars:\\n modform_var = var.strip()\\n \\n # forcing all the variables in this constraint to be zero\\n self._linear_constraints.modform_space.D_PuLP_variables[modform_var] = pulp.LpVariable(modform_var, lowBound=0, upBound=0)\\n #print \\\"var forced to zero: \\\", modform_var\\n L_zero_var.append(modform_var)\\n else: #if float(rhs)==0\\n continue\\n \\n if len(L_zero_var)>0:\\n print \\\"\\\\n####### Variables forced to zero (rhs = 0) ##########\\\"\\n print \\\"variables forced to zero: \\\", set(L_zero_var)\\n \\n feasible_lc = flc.FeasibleLinearConstraints(self._linear_constraints)\\n \\n feasible_lc.get_feasible_linear_constraints()\\n \\n feasible_linear_constraints = feasible_lc.feasible_linear_constraints\\n \\n lp_solver = lps.LinearProgrammingSolver(feasible_linear_constraints)\\n \\n D_lower_bounds = {}; D_upper_bounds = {}\\n \\n for v in [self._linear_constraints.modform_space.D_PuLP_variables[k] for k in sorted(self._linear_constraints.modform_space.D_PuLP_variables.keys(), key=gbfunc.natural_keys)]:\\n \\n if str(v) in L_zero_var:\\n D_lower_bounds[str(v)] = '0'\\n D_upper_bounds[str(v)] = '0'\\n continue\\n #end if str(v) in L_zero_var\\n \\n objective_function_PuLP = v\\n \\n list_values_minimize = lp_solver.linear_programming_solver(objective_function_PuLP, pulp.LpMinimize)\\n D_lower_bounds[str(v)] = \\\"%.3f\\\"%round(pulp.value(v),3)\\n \\n list_values_maximize = lp_solver.linear_programming_solver(objective_function_PuLP, pulp.LpMaximize)\\n D_upper_bounds[str(v)] = \\\"%.3f\\\"%round(pulp.value(v),3)\\n\\n #end for v in ..\\n\\n return((D_lower_bounds, D_upper_bounds))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59818715","0.59583765","0.5903426","0.5859693","0.58076525","0.5784628","0.5665552","0.5640563","0.5586638","0.5551454","0.5532172","0.5490747","0.54334694","0.5426477","0.5416738","0.54091454","0.54014874","0.5349996","0.5336917","0.5335465","0.5335465","0.5327792","0.53235096","0.53171754","0.52862585","0.5286126","0.52795374","0.52350026","0.523473","0.52281195","0.52152044","0.5211846","0.52066374","0.5200392","0.51949877","0.5190858","0.5179017","0.5176687","0.51725304","0.5138671","0.51377785","0.51370454","0.51346236","0.51314384","0.5107714","0.5089548","0.50882864","0.5079448","0.50671107","0.5058447","0.504425","0.5044169","0.5032889","0.5016049","0.5009389","0.50070435","0.5004968","0.4999103","0.4997135","0.4995988","0.4993837","0.49903342","0.49811462","0.49760035","0.49667865","0.49652836","0.49636626","0.49630532","0.49612683","0.49534422","0.49524117","0.49512905","0.49471015","0.4942343","0.4937082","0.49336612","0.4916538","0.4915296","0.49150586","0.49141994","0.4910184","0.49044964","0.49002346","0.4898402","0.48934296","0.48883748","0.4887256","0.48841408","0.48771104","0.48732433","0.48509958","0.485082","0.48474","0.48397675","0.48386937","0.4834713","0.48317516","0.48291913","0.4824222"],"string":"[\n \"0.59818715\",\n \"0.59583765\",\n \"0.5903426\",\n \"0.5859693\",\n \"0.58076525\",\n \"0.5784628\",\n \"0.5665552\",\n \"0.5640563\",\n \"0.5586638\",\n \"0.5551454\",\n \"0.5532172\",\n \"0.5490747\",\n \"0.54334694\",\n \"0.5426477\",\n \"0.5416738\",\n \"0.54091454\",\n \"0.54014874\",\n \"0.5349996\",\n \"0.5336917\",\n \"0.5335465\",\n \"0.5335465\",\n \"0.5327792\",\n \"0.53235096\",\n \"0.53171754\",\n \"0.52862585\",\n \"0.5286126\",\n \"0.52795374\",\n \"0.52350026\",\n \"0.523473\",\n \"0.52281195\",\n \"0.52152044\",\n \"0.5211846\",\n \"0.52066374\",\n \"0.5200392\",\n \"0.51949877\",\n \"0.5190858\",\n \"0.5179017\",\n \"0.5176687\",\n \"0.51725304\",\n \"0.5138671\",\n \"0.51377785\",\n \"0.51370454\",\n \"0.51346236\",\n \"0.51314384\",\n \"0.5107714\",\n \"0.5089548\",\n \"0.50882864\",\n \"0.5079448\",\n \"0.50671107\",\n \"0.5058447\",\n \"0.504425\",\n \"0.5044169\",\n \"0.5032889\",\n \"0.5016049\",\n \"0.5009389\",\n \"0.50070435\",\n \"0.5004968\",\n \"0.4999103\",\n \"0.4997135\",\n \"0.4995988\",\n \"0.4993837\",\n \"0.49903342\",\n \"0.49811462\",\n \"0.49760035\",\n \"0.49667865\",\n \"0.49652836\",\n \"0.49636626\",\n \"0.49630532\",\n \"0.49612683\",\n \"0.49534422\",\n \"0.49524117\",\n \"0.49512905\",\n \"0.49471015\",\n \"0.4942343\",\n \"0.4937082\",\n \"0.49336612\",\n \"0.4916538\",\n \"0.4915296\",\n \"0.49150586\",\n \"0.49141994\",\n \"0.4910184\",\n \"0.49044964\",\n \"0.49002346\",\n \"0.4898402\",\n \"0.48934296\",\n \"0.48883748\",\n \"0.4887256\",\n \"0.48841408\",\n \"0.48771104\",\n \"0.48732433\",\n \"0.48509958\",\n \"0.485082\",\n \"0.48474\",\n \"0.48397675\",\n \"0.48386937\",\n \"0.4834713\",\n \"0.48317516\",\n \"0.48291913\",\n \"0.4824222\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.52924377"},"document_rank":{"kind":"string","value":"24"}}},{"rowIdx":87198,"cells":{"query":{"kind":"string","value":"Generate the numerical code."},"document":{"kind":"string","value":"def generate(self, sorder):\n from .generator import For\n from .symbolic import nx, ny, nz, indexed, ix\n\n ns = int(self.stencil.nv_ptr[-1])\n dim = self.stencil.dim\n\n istore, iload, ncond = self._get_istore_iload_symb(dim)\n rhs, dist = self._get_rhs_dist_symb(ncond)\n\n idx = Idx(ix, (0, ncond))\n fstore = indexed(\n \"f\",\n [ns, nx, ny, nz],\n index=[istore[idx, k] for k in range(dim + 1)],\n priority=sorder,\n )\n fload0 = indexed(\n \"fcopy\",\n [ns, nx, ny, nz],\n index=[iload[0][idx, k] for k in range(dim + 1)],\n priority=sorder,\n )\n fload1 = indexed(\n \"fcopy\",\n [ns, nx, ny, nz],\n index=[iload[1][idx, k] for k in range(dim + 1)],\n priority=sorder,\n )\n\n self.generator.add_routine(\n (\n \"Bouzidi_bounce_back\",\n For(\n idx,\n Eq(\n fstore, dist[idx] * fload0 + (1 - dist[idx]) * fload1 + rhs[idx]\n ),\n ),\n )\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 code(self):\n if not self._code:\n filename = '<fluxtools function %s>' % self.tag\n self._code = compile(self.math, filename, mode='eval')\n return self._code","def _get_random_number_code(self):\r\n return \"str(random.randint(0, 1e9))\"","def number(self):","def gen_code(self, filename, func_name):\n\n assert self.bits is not None\n\n vd_list = []\n n_vars = 0\n for tree in self.trees:\n vd_list.append(tree.gen_code(n_vars))\n n_vars += len(vd_list[-1])\n\n # checks the type by the suffix\n\n is_v = filename.split(\".\")[-1] == \"v\"\n\n assert self.inputs\n\n f = open(filename, \"w\")\n\n i_bits = np.sum(self.bits[:-1])\n o_bits = self.bits[-1]\n o_sign = self.is_neg[-1]\n\n if is_v:\n f.write(\"module {}(input [{}:0] i, output [{}:0] o);\\n\".format(\n func_name, i_bits-1, o_bits-1))\n else:\n f.write(\"#include<ac_int.h>\\n\\n\")\n f.write(\"void {}(ac_int<{},false> i, ac_int<{},{}> &o)\\n\".format(\n func_name, i_bits, o_bits, o_sign))\n f.write(\"{\\n\")\n\n\n # write function headline\n s_in_line = []\n\n i_bits = self.bits[0]\n i_sign = self.is_neg[0]\n\n if is_v:\n i_datatype = \" wire {}[{}:0] \".format(\n \"signed \" if i_sign else \"\", i_bits-1)\n else:\n i_datatype = \" ac_int<{},{}> \".format(i_bits, i_sign)\n\n len_s = len(i_datatype)\n\n for i in range(self.inputs):\n if is_v:\n s = (\n \"i_\" + str(i) + \" = \" + \"i[\" + str(i_bits*(i+1)-1) + \":\" +\n str(i_bits*i) + \"]\"\n )\n else:\n s = (\n \"i_\" + str(i) + \" = \" + \"i.slc<\" + str(i_bits) + \">(\" +\n str(i_bits*i) + \")\"\n )\n if (\n len_s + len(s) + 2 > 70 or i_bits != self.bits[i] or\n i_sign != self.is_neg[i]\n ):\n f.write(i_datatype + \", \".join(s_in_line) + \";\\n\")\n\n s_in_line = []\n if is_v:\n i_datatype = \" wire {}[{}:0] \".format(\n \"signed \" if i_sign else \"\", i_bits-1)\n else:\n i_datatype = \" ac_int<{},{}> \".format(i_bits, i_sign)\n\n len_s = len(i_datatype)\n\n s_in_line.append(s)\n len_s += len(s) + 2\n\n if s_in_line:\n f.write(i_datatype + \", \".join(s_in_line) + \";\\n\")\n\n if is_v:\n o_datatype = \" wire {}[{}:0] \".format(\n \"signed \" if o_sign else \"\", o_bits)\n else:\n o_datatype = \" ac_int<{},{}> \".format(o_bits, o_sign)\n\n o_list = []\n for i in range(len(vd_list)):\n for v in vd_list[i]:\n if is_v:\n f.write(o_datatype + v + \" = \" + vd_list[i][v] + \";\\n\")\n else:\n f.write(o_datatype + v + \" = \" + vd_list[i][v] + \";\\n\")\n f.write(\"\\n\")\n o_list.append(v)\n\n assert len(o_list) <= 3\n\n if is_v:\n f.write(\" assign \")\n else:\n f.write(\" \")\n\n if len(o_list) == 1:\n f.write(\"o = \" + o_list[0] + \";\")\n elif len(o_list) == 2:\n cond = \"( \" + o_list[0] + \" == \" + o_list[1] + \" ) \"\n n1 = o_list[0]\n n0 = \"( ( \" + \" + \".join(o_list) + \" ) >> 1 )\"\n f.write(\"o = \" + cond + \"? \" + n1 + \": \" + n0)\n elif len(o_list) == 3:\n cond = (\n \"( \" +\n \"( \" + \" == \".join(o_list[0:2]) + \" )?\" + o_list[0] + \":\" +\n \"( \" + \" == \".join(o_list[1:]) + \" )?\" + o_list[1] + \":\" +\n \"( \" + \" == \".join([o_list[0], o_list[2]]) + \" )?\" + o_list[0] +\n \":\" + \"( \" + \" < \".join(o_list[0:2]) + \" ) ?\" +\n \"( ( \" + \" < \".join(o_list[1:]) + \" ) ?\" + o_list[1] + \":\" +\n o_list[2] + \" ) : \" +\n \"( ( \" + \" < \".join([o_list[0], o_list[2]]) + \" ) ?\" + o_list[0] +\n \":\" + o_list[2] + \" )\"\n )\n f.write(\"o = \" + cond + \";\\n\")\n if is_v:\n f.write(\"endmodule\")\n else:\n f.write(\"}\")\n\n f.close()","def nr():\n pass","def generation(x, g):\n return int(x/g)","def gen_numeric_literal(self, expr):\n return self.emit_const(expr.value, expr.typ)","def _gen_code(self):\r\n #TODO: maybe generate one C function only to save compile time? Also easier to take that as a basis and hand craft other covariances??\r\n\r\n #generate c functions from sympy objects \r\n argument_sequence = self._sp_x+self._sp_z+self._sp_theta\r\n code_list = [('k',self._sp_k)]\r\n # gradients with respect to covariance input\r\n code_list += [('dk_d%s'%x.name,dx) for x,dx in zip(self._sp_x,self._sp_dk_dx)]\r\n # gradient with respect to parameters\r\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta,self._sp_dk_dtheta)]\r\n # gradient with respect to multiple output parameters\r\n if self.output_dim > 1:\r\n argument_sequence += self._sp_theta_i + self._sp_theta_j\r\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta_i,self._sp_dk_dtheta_i)]\r\n (foo_c,self._function_code), (foo_h,self._function_header) = \\\r\n codegen(code_list, \"C\",'foobar',argument_sequence=argument_sequence)\r\n #put the header file where we can find it\r\n f = file(os.path.join(tempfile.gettempdir(),'foobar.h'),'w')\r\n f.write(self._function_header)\r\n f.close()\r\n\r\n # Substitute any known derivatives which sympy doesn't compute\r\n self._function_code = re.sub('DiracDelta\\(.+?,.+?\\)','0.0',self._function_code)\r\n\r\n\r\n ############################################################\r\n # This is the basic argument construction for the C code. #\r\n ############################################################\r\n \r\n arg_list = ([\"X2(i, %s)\"%x.name[2:] for x in self._sp_x]\r\n + [\"Z2(j, %s)\"%z.name[2:] for z in self._sp_z])\r\n\r\n # for multiple outputs need to also provide these arguments reversed.\r\n if self.output_dim>1:\r\n reverse_arg_list = list(arg_list)\r\n reverse_arg_list.reverse()\r\n\r\n # Add in any 'shared' parameters to the list.\r\n param_arg_list = [shared_params.name for shared_params in self._sp_theta]\r\n arg_list += param_arg_list\r\n\r\n precompute_list=[]\r\n if self.output_dim > 1:\r\n reverse_arg_list+=list(param_arg_list)\r\n split_param_arg_list = [\"%s1(%s)\"%(theta.name[:-2].upper(),index) for index in ['ii', 'jj'] for theta in self._sp_theta_i]\r\n split_param_reverse_arg_list = [\"%s1(%s)\"%(theta.name[:-2].upper(),index) for index in ['jj', 'ii'] for theta in self._sp_theta_i]\r\n arg_list += split_param_arg_list\r\n reverse_arg_list += split_param_reverse_arg_list\r\n # Extract the right output indices from the inputs.\r\n c_define_output_indices = [' '*16 + \"int %s=(int)%s(%s, %i);\"%(index, var, index2, self.input_dim-1) for index, var, index2 in zip(['ii', 'jj'], ['X2', 'Z2'], ['i', 'j'])]\r\n precompute_list += c_define_output_indices\r\n reverse_arg_string = \", \".join(reverse_arg_list)\r\n arg_string = \", \".join(arg_list)\r\n precompute_string = \"\\n\".join(precompute_list)\r\n\r\n # Code to compute argments string needed when only X is provided.\r\n X_arg_string = re.sub('Z','X',arg_string)\r\n # Code to compute argument string when only diagonal is required.\r\n diag_arg_string = re.sub('int jj','//int jj',X_arg_string)\r\n diag_arg_string = re.sub('j','i',diag_arg_string)\r\n if precompute_string == '':\r\n # if it's not multioutput, the precompute strings are set to zero\r\n diag_precompute_string = ''\r\n diag_precompute_replace = ''\r\n else:\r\n # for multioutput we need to extract the index of the output form the input.\r\n diag_precompute_string = precompute_list[0]\r\n diag_precompute_replace = precompute_list[1]\r\n \r\n\r\n # Here's the code to do the looping for K\r\n self._K_code =\\\r\n \"\"\"\r\n // _K_code\r\n // Code for computing the covariance function.\r\n int i;\r\n int j;\r\n int N = target_array->dimensions[0];\r\n int num_inducing = target_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N;i++){\r\n for (j=0;j<num_inducing;j++){\r\n%s\r\n //target[i*num_inducing+j] = \r\n TARGET2(i, j) += k(%s);\r\n }\r\n }\r\n %s\r\n \"\"\"%(precompute_string,arg_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n\r\n self._K_code_X = \"\"\"\r\n // _K_code_X\r\n // Code for computing the covariance function.\r\n int i;\r\n int j;\r\n int N = target_array->dimensions[0];\r\n int num_inducing = target_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N;i++){\r\n %s // int ii=(int)X2(i, 1);\r\n TARGET2(i, i) += k(%s);\r\n for (j=0;j<i;j++){\r\n %s //int jj=(int)X2(j, 1);\r\n double kval = k(%s); //double kval = k(X2(i, 0), shared_lengthscale, LENGTHSCALE1(ii), SCALE1(ii));\r\n TARGET2(i, j) += kval;\r\n TARGET2(j, i) += kval;\r\n }\r\n }\r\n /*%s*/\r\n \"\"\"%(diag_precompute_string, diag_arg_string, re.sub('Z2', 'X2', diag_precompute_replace), X_arg_string,str(self._sp_k)) #adding a string representation forces recompile when needed\r\n\r\n # Code to do the looping for Kdiag\r\n self._Kdiag_code =\\\r\n \"\"\"\r\n // _Kdiag_code\r\n // Code for computing diagonal of covariance function.\r\n int i;\r\n int N = target_array->dimensions[0];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for\r\n for (i=0;i<N;i++){\r\n %s\r\n //target[i] =\r\n TARGET1(i)=k(%s);\r\n }\r\n %s\r\n \"\"\"%(diag_precompute_string,diag_arg_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n\r\n # Code to compute gradients\r\n grad_func_list = []\r\n if self.output_dim>1:\r\n grad_func_list += c_define_output_indices\r\n grad_func_list += [' '*16 + 'TARGET1(%i+ii) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, arg_string) for i, theta in enumerate(self._sp_theta_i)]\r\n grad_func_list += [' '*16 + 'TARGET1(%i+jj) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, reverse_arg_string) for i, theta in enumerate(self._sp_theta_i)]\r\n grad_func_list += ([' '*16 + 'TARGET1(%i) += PARTIAL2(i, j)*dk_d%s(%s);'%(i,theta.name,arg_string) for i,theta in enumerate(self._sp_theta)])\r\n grad_func_string = '\\n'.join(grad_func_list) \r\n\r\n self._dK_dtheta_code =\\\r\n \"\"\"\r\n // _dK_dtheta_code\r\n // Code for computing gradient of covariance with respect to parameters.\r\n int i;\r\n int j;\r\n int N = partial_array->dimensions[0];\r\n int num_inducing = partial_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N;i++){\r\n for (j=0;j<num_inducing;j++){\r\n%s\r\n }\r\n }\r\n %s\r\n \"\"\"%(grad_func_string,\"/*\"+str(self._sp_k)+\"*/\") # adding a string representation forces recompile when needed\r\n\r\n\r\n # Code to compute gradients for Kdiag TODO: needs clean up\r\n diag_grad_func_string = re.sub('Z','X',grad_func_string,count=0)\r\n diag_grad_func_string = re.sub('int jj','//int jj',diag_grad_func_string)\r\n diag_grad_func_string = re.sub('j','i',diag_grad_func_string)\r\n diag_grad_func_string = re.sub('PARTIAL2\\(i, i\\)','PARTIAL1(i)',diag_grad_func_string)\r\n self._dKdiag_dtheta_code =\\\r\n \"\"\"\r\n // _dKdiag_dtheta_code\r\n // Code for computing gradient of diagonal with respect to parameters.\r\n int i;\r\n int N = partial_array->dimensions[0];\r\n int input_dim = X_array->dimensions[1];\r\n for (i=0;i<N;i++){\r\n %s\r\n }\r\n %s\r\n \"\"\"%(diag_grad_func_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n\r\n # Code for gradients wrt X, TODO: may need to deal with special case where one input is actually an output.\r\n gradX_func_list = []\r\n if self.output_dim>1:\r\n gradX_func_list += c_define_output_indices\r\n gradX_func_list += [\"TARGET2(i, %i) += PARTIAL2(i, j)*dk_dx_%i(%s);\"%(q,q,arg_string) for q in range(self._real_input_dim)]\r\n gradX_func_string = \"\\n\".join(gradX_func_list)\r\n\r\n self._dK_dX_code = \\\r\n \"\"\"\r\n // _dK_dX_code\r\n // Code for computing gradient of covariance with respect to inputs.\r\n int i;\r\n int j;\r\n int N = partial_array->dimensions[0];\r\n int num_inducing = partial_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N; i++){\r\n for (j=0; j<num_inducing; j++){\r\n %s\r\n }\r\n }\r\n %s\r\n \"\"\"%(gradX_func_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n \r\n\r\n diag_gradX_func_string = re.sub('Z','X',gradX_func_string,count=0)\r\n diag_gradX_func_string = re.sub('int jj','//int jj',diag_gradX_func_string)\r\n diag_gradX_func_string = re.sub('j','i',diag_gradX_func_string)\r\n diag_gradX_func_string = re.sub('PARTIAL2\\(i, i\\)','2*PARTIAL1(i)',diag_gradX_func_string)\r\n\r\n # Code for gradients of Kdiag wrt X\r\n self._dKdiag_dX_code= \\\r\n \"\"\"\r\n // _dKdiag_dX_code\r\n // Code for computing gradient of diagonal with respect to inputs.\r\n int N = partial_array->dimensions[0];\r\n int input_dim = X_array->dimensions[1];\r\n for (int i=0;i<N; i++){\r\n %s\r\n }\r\n %s\r\n \"\"\"%(diag_gradX_func_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a\r\n # string representation forces recompile when needed Get rid\r\n # of Zs in argument for diagonal. TODO: Why wasn't\r\n # diag_func_string called here? Need to check that.\r\n #self._dKdiag_dX_code = self._dKdiag_dX_code.replace('Z[j', 'X[i')\r\n\r\n # Code to use when only X is provided. \r\n self._dK_dtheta_code_X = self._dK_dtheta_code.replace('Z[', 'X[')\r\n self._dK_dX_code_X = self._dK_dX_code.replace('Z[', 'X[').replace('+= PARTIAL2(', '+= 2*PARTIAL2(') \r\n self._dK_dtheta_code_X = self._dK_dtheta_code_X.replace('Z2(', 'X2(')\r\n self._dK_dX_code_X = self._dK_dX_code_X.replace('Z2(', 'X2(')\r\n\r\n\r\n #TODO: insert multiple functions here via string manipulation\r\n #TODO: similar functions for psi_stats\r","def numerize():\n pass","def numeric(*args):","def generate_cpp():\n cpp_file = AUTOGEN_WARNING\n cpp_file += \"// Implements basic nuclear data functions.\\n\"\n cpp_file += \"#ifndef PYNE_IS_AMALGAMATED\\n\"\n cpp_file += '#include \"atomic_data.h\"\\n'\n cpp_file += '#include \"nucname.h\"\\n'\n cpp_file += \"#endif\\n\"\n cpp_file += \" \\n\"\n cpp_file += \"void pyne::_load_atomic_mass_map_memory() { \\n\"\n cpp_file += \" // header version of atomic weight table data \\n\"\n cpp_file += \" //see if the data table is already loaded\\n\"\n cpp_file += \" if(!atomic_mass_map.empty()) {\\n\"\n cpp_file += \" return;\\n\"\n cpp_file += \" } else { \\n\"\n cpp_file += \" _insert_atomic_mass_map();\\n\"\n cpp_file += \" }\\n\"\n cpp_file += \" //see if the data table is already loaded\\n\"\n cpp_file += \" if(!natural_abund_map.empty()) {\\n\"\n cpp_file += \" return;\\n\"\n cpp_file += \" } else { \\n\"\n cpp_file += \" _insert_abund_map();\\n\"\n cpp_file += \" }\\n\"\n cpp_file += \" // calculate the atomic_masses of the elements \\n\"\n cpp_file += \" std::map<int,double> :: iterator it;\\n\"\n cpp_file += \" \\n\"\n cpp_file += \" for (int z = 1; z <= 92 ; z++) {\\n\"\n cpp_file += \" // loop through the natural abundance map\\n\"\n cpp_file += \" double element_atomic_weight = 0.0;\\n\"\n cpp_file += \" for (it = natural_abund_map.begin(); it != natural_abund_map.end() ; ++it){\\n\"\n cpp_file += \" // if the atomic number of the abudance matches the\\n\"\n cpp_file += \" // that of index\\n\"\n cpp_file += \" if(pyne::nucname::znum(it->first) == z) {\\n\"\n cpp_file += \" // take atomic abundance and multiply by mass\\n\"\n cpp_file += (\n \" // to get the mass of that nuclide / 100 since abundance is in %\\n\"\n )\n cpp_file += \" element_atomic_weight += (it->second*atomic_mass_map[it->first]/100.0);\\n\"\n cpp_file += \" }\\n\"\n cpp_file += \" }\\n\"\n cpp_file += \" // insert the abundance of the element into the list\\n\"\n cpp_file += \" atomic_mass_map[z*10000000] = element_atomic_weight;\\n\"\n cpp_file += \" }\\n\"\n cpp_file += \"}\\n\"\n cpp_file += \"\\n\\n\"\n cpp_file += \"void pyne::_insert_atomic_mass_map() { \\n\"\n cpp_file += generate_atomic_mass()\n cpp_file += \"}\\n\"\n cpp_file += \"\\n\\n\"\n cpp_file += \"void pyne::_insert_abund_map() { \\n\"\n cpp_file += generate_abundances()\n cpp_file += \"}\\n\"\n return cpp_file","def generate():","def genCode(self):\n # Init variables and environment.\n if 'Sys' in self.inputs:\n self.cg_bootstrap_sys()\n\n for ns, vm_code in self.inputs.items():\n input = Parser(vm_code).parse()\n self.ns = ns\n\n if input['errors']:\n # No meaningful output can be generated.\n # Print errors to stderr and return empty string.\n print(\"ERRORS\", file=sys.stderr)\n for err in input['errors']:\n print(\"Line {}: {}\".format(err.line, err.msg))\n return f\"// Encountered errors parsing {filename}\"\n\n # Translate input.\n self.asm(f\"// Input file: {ns}\")\n for cmd in input['commands']:\n # Print original VM command as a comment.\n self.asm('// ' + cmd.src)\n self.cg(cmd)\n self.asm(f\"// End of input file: {ns}\")\n\n # Add the stop loop.\n self.cg_stop()\n\n return '\\n'.join(self.text)","def curve_number(self):","def v_numeric(self, **kwargs):\n self.system.groups['StaticGen'].set(src='u', idx=self.gen.v, attr='v', value=0)","def getNumber():","def gen_code():\n return ''.join([random.choice(string.ascii_uppercase + string.digits) for _ in range(10)])","def generate(self):\n tempSn_1 = self.sn_1\n self.sn_1 = (self.an_2*self.sn_2 + self.an_1*self.sn_1) % self.mod\n self.sn_2 = tempSn_1\n return self.sn_1 / self.mod","def main():\n result = 0\n for n in range(1, 1001):\n result += n**n\n\n result = str(result)\n answer = result[len(result)-10::]\n\n print \"answer: \" + answer","def generate_swift_code(self, num):\n swift_code = []\n for _ in range(num):\n swift_code.append(self.fake.swift())\n return swift_code","def gencode(self):\n\n fullcode = self.code_cfg\n variables = codeconfig_getvars(fullcode)\n if len(variables) > 0:\n variables.sort(key=lambda x: len(x), reverse=True)\n for va in variables:\n if eval(\"self.\" + va[1:]) is None or eval(\"self.\" + va[1:]) == \"\":\n warnings.warn(\"Inserting None for \" + va, UserWarning)\n fullcode = fullcode.replace(va, str(eval(\"self.\" + va[1:])))\n # testing for sintax errors\n #compile(fullcode, \"<Test ModelCall Code>\\n\" + fullcode, 'exec')\n tmpfile = os.path.join(gettempdir(), \"TestModelCallCode.\" + self.complexity + \".py\")\n with open(tmpfile, \"w\") as f: f.write(fullcode)\n compile(fullcode, tmpfile, 'exec')\n return fullcode","def code():","def test_numbers(self):\n \n result = gen_expansion(sym.pi, 2)\n self.assertEqual(result, '14')\n result = gen_expansion(sym.exp(1), 2)\n self.assertEqual(result, '72')","def evaluate(self) -> int:","def _pettifor_numbers():\n return { \"Li\": 0.45,\n \"Be\": 1.5,\n \"B\": 2.0,\n \"C\": 2.5,\n \"N\": 3.0, \n \"O\": 3.5,\n \"F\": 4.0,\n \n \"Na\": 0.4,\n \"Mg\": 1.28,\n \"Al\": 1.66,\n \"Si\": 1.92,\n \"P\": 2.18,\n \"S\": 2.44,\n \"Cl\": 2.70,\n \n \"K\": 0.35,\n \"Ca\": 0.60,\n \"Sc\": 0.74,\n \"Ti\": 0.79,\n \"V\": 0.84,\n \"Cr\": 0.89,\n \"Mn\": 0.94,\n \"Fe\": 0.99,\n \"Co\": 1.04,\n \"Ni\": 1.09,\n \"Cu\": 1.20,\n \"Zn\": 1.44,\n \"Ga\": 1.68,\n \"Ge\": 1.92,\n \"As\": 2.16,\n \"Se\": 2.40,\n \"Br\": 2.64,\n\n \"Rb\": 0.30,\n \"Sr\": 0.55,\n \"Y\": 0.70,\n \"Zr\": 0.76,\n \"Nb\": 0.82,\n \"Mo\": 0.88,\n \"Tc\": 0.94,\n \"Ru\": 1.00,\n \"Rh\": 1.06,\n \"Pd\": 1.12,\n \"Ag\": 1.18,\n \"Cd\": 1.36,\n \"In\": 1.60,\n \"Sn\": 1.84,\n \"Sb\": 2.08,\n \"Te\": 2.32,\n \"I\": 2.56,\n \n \"Cs\": 0.25,\n \"Ba\": 0.50,\n \"La\": 0.748,\n \"Hf\": 0.775,\n \"Ta\": 0.83,\n \"W\": 0.885,\n \"Re\": 0.94,\n \"Os\": 0.995,\n \"Ir\": 1.05,\n \"Pt\": 1.105,\n \"Au\": 1.16,\n \"Hg\": 1.32,\n \"Tl\": 1.56,\n \"Pb\": 1.80,\n \"Bi\": 2.04,\n \"Po\": 2.28, \n \"At\": 2.52 }","def Mo96(self,dc,nu):\n return 1. + (nu**2.-1.)/dc","def _generate_code_blocks(self):\n\n printer = self._generate_pydy_c_printer()()\n\n self.code_blocks = {}\n\n lines = []\n for i, input_arg in enumerate(self.arguments):\n lines.append('double input_{}[{}],'.format(i, len(input_arg)))\n self.code_blocks['input_args'] = wrap_and_indent(lines, 14)\n\n lines = []\n for i, output_arg in enumerate(self.matrices):\n nr, nc = output_arg.shape\n lines.append('double output_{}[{}],'.format(i, nr * nc))\n self.code_blocks['output_args'] = \\\n wrap_and_indent(lines, 14)[:-1] # remove last comma\n\n lines = []\n for i, (input_arg, explan) in enumerate(zip(self.arguments,\n self.comma_lists())):\n lines.append('input_{}[{}] : [{}]'.format(i, len(input_arg),\n explan))\n self.code_blocks['input_docstring'] = wrap_and_indent(lines, 0)\n\n lines = []\n for var, expr in self.subexprs:\n var_str = printer.doprint(var)\n expr_str = printer.doprint(expr)\n lines.append('double {} = {};'.format(var_str, expr_str))\n self.code_blocks['subexprs'] = wrap_and_indent(lines)\n\n outputs = ''\n for i, output in enumerate(self.simplified_matrices):\n nr, nc = output.shape\n lhs = sm.MatrixSymbol('output_{}'.format(i), nr, nc)\n try:\n code_str = printer.doprint(output, lhs)\n except AttributeError:\n # The above fails in SymPy 0.7.4.1 because Matrix printing\n # isn't supported.\n code_lines = []\n for j, element in enumerate(output):\n assignment = 'output_{}[{}]'.format(i, j)\n code_lines.append(printer.doprint(element, assignment))\n code_str = '\\n'.join(code_lines)\n outputs += wrap_and_indent(code_str.split('\\n'))\n if i != len(self.simplified_matrices) - 1:\n outputs += '\\n\\n' # space between each output\n\n self.code_blocks['outputs'] = outputs","def main():\n for i in range(11):\n i = i / 10\n print('L * 1000', i, L(i) * 1000)","def data_generation():\n num1 = random.randint(1, 100)\n num2 = random.randint(1, 100)\n correct_answer = math.gcd(num1, num2)\n expression = f'{num1} {num2}'\n return expression, str(correct_answer)","def code_str(self, fn_name):\n code = CodeWriter()\n code.wl(\"def \" + fn_name + \"(y):\")\n code.inc_indent()\n if self.m == 1:\n code.wl(\"x = \" + str(self._a) + \" * y + \" + str(self._b))\n else:\n code.wl(\"a = np.\" + self._a.__repr__())\n code.wl(\"b = np.\" + self._b.__repr__())\n code.wl(\"x = np.dot(a, y) + b\")\n poly_eval_code = self._unit_simplex_polynomial.code_str(\"temp\")\n poly_eval_code = poly_eval_code.split('\\n')[1:]\n poly_eval_code = \"\\n\".join(poly_eval_code)\n code.verbatim(poly_eval_code)\n code.dec_indent()\n return code.code","def generate(bits):\r\n raise NotImplementedError()","def _generate_code(x, functional):\n\n printer = sympy.printing.lambdarepr.PythonCodePrinter()\n\n code = \"def evaluate(values, solution):\\n\"\n code += \"\\tfor k in range(len(values)):\\n\"\n code += \"\\t\\t\" + \", \".join(str(state) for state in x) + \" = solution[k]\\n\"\n code += f\"\\t\\tvalues[k] = {printer.doprint(functional.evalf())}\\n\"\n return code","def generate(self):","def code() -> str:\n return \"\"\"\n G91 G17\n G0 Y10 X-10\n G0 Y0 X-5\n G0 Y5 X0\n G0 Y0 X5\n G0 Y0 X-5\n G0 Y-5 X0\n G3 Y-5 X5 J0 I5\n G0 Y0 X5\n G0 Y5 X0\n G3 Y5 X-5 J0 I-5\n G0 Y-5 X0\n G0 Y-10 X10\n G0 Y0 X-5\n G0 Y-15 X-15\n G0 Y0 X5\n G0 Y5 X0\n G0 Y0 X-5\n G0 Y-5 X0\n G0 Y5 X0\n G2 Y5 X5 J0 I5\n G0 Y0 X5\n G0 Y-5 X0\n G2 Y-5 X-5 J0 I-5\n G0 Y5 X0\n G0 Y10 X10\n G0 Y0 X-30\n G3 Y0 X-10 J0 I-5\n G3 Y0 X10 J0 I5\n\n G0 Y0 X5\n G3 Y5 X5 J5 I0\n G3 Y10 X-10 J0 I-10\n G3 Y-5 X-5 J-5 I0\n G0 Y-5 X0\n\n G0 Y5 X0\n G3 Y5 X-5 J0 I-5\n G3 Y-10 X-10 J-10 I0\n G3 Y-5 X5 J0 I5\n G0 Y0 X5\n\n G0 Y0 X-5\n G3 Y-5 X-5 J-5 I0\n G3 Y-10 X10 J0 I10\n G3 Y5 X5 J5 I0\n G0 Y5 X0\n\n G0 Y-5 X0\n G3 Y-5 X5 J0 I5\n G3 Y10 X10 J10 I0\n G3 Y5 X-5 J0 I-5\n G0 Y0 X-5\n \"\"\"","def calculate(self):\n\n outs = map(str, map(self.translate, self.nums))\n result = \"\\n\".join(outs)\n\n return str(result)","def test_generate_nb(self):\n pass","def __math__(inputs: list) -> str:\n # TODO: Find new way of indicating that a variable should be used instead of a static value.\n\n out = \"\"\n if len(inputs) < 2:\n return None # TODO: create error and throw that instead\n fname, func = inspect.getmembers(math, inspect.isbuiltin)[inputs[0]]\n out += fname + \"(\"\n nvars = MachineInterface.__math_doc_nvars__(func.__doc__)\n if nvars == 1:\n out += str(inputs[1]) + \",\"\n else:\n for i in range(1, nvars):\n out += str(inputs[i % len(inputs)]) + \",\"\n\n return out[:-1] + \")\"\n # b = func.__doc__\n # print(dir(func))\n # print(b)\n # print(dir(b))\n # print(inspect.signature(b)","def code_format(self):\n return \"^\\\\d{%s}$\" % self._digits","def make_g_number():\n return fake.bothify(text='??#########')","def y(self) -> int:","def GenerateCode(self):\n print \"Generating code...\"\n for type in self.getObjectTypes():\n generator = __import__(\"codegen.Cpp\" + type, globals(), locals(), [''])\n print \"Generating code for objects of type: %s\" % type\n generator.GenerateCode(self)","def function(self):\n return self.generator.module.neumannx","def random_num(self):\r\n self.generate_n1()\r\n self.generate_n2()\r\n self.generate_n3()\r\n self.generate_n4()\r\n random_number = str(self.n_1decimal)+str(self.n_2decimal)+str(self.n_3decimal)+str(self.n_4decimal)\r\n print int(random_number)","def generate_new_code():\n code = ''.join(random.choice(string.digits) for i in range(6))\n return code","def GenerateNormalExpression(n):\n if int(n) != n or n < 1:\n return None\n return '+'.join(['a[%d]' % ii for ii in range(n)])","def make_code(self, datasetname):\n try:\n if(datasetname):\n for i in range(1, len(self.extract()) + 1):\n self.formated = datasetname + \"%03d\" % (i,)\n yield self.formated \n except:\n raise","def NACA4digitsSym(self):\n self.ytu = self.NacaEquation(self.xu,self.t)\n self.ytl = -self.NacaEquation(self.xl,self.t)\n # Done for estitic reasons\n self.yu = self.ytu \n self.yl = self.ytl\n self.z = np.concatenate((self.yu, np.flip(self.yl)))\n if self.plot:\n plt.figure(self.name)\n plt.title(self.name)\n plt.plot(self.xu,self.yu)\n plt.plot(self.xl,self.yl)\n plt.axis('equal')","def generate(self):\r\n raise NotImplementedError","def generate_code(model, dataloader, code_length, device):\n model.eval()\n with torch.no_grad():\n N = len(dataloader.dataset)\n code = torch.zeros([N, code_length])\n for data, _, index in dataloader:\n data = data.to(device)\n hash_code = model(data)\n code[index, :] = hash_code.sign().cpu()\n\n model.train()\n return code","def gen_amounts(no_cultures):\n # Init amounts\n C = 0.01\n N = 1.0\n S = 0.0\n init_amounts = np.array([C, N, S]*no_cultures)\n return init_amounts","def calculate_output(self):","def Codingfunc(N,L): #Coding:[N:number of repetitions, L:length of single/multiple sequence]\r\n C=0 #int variable containing code number\r\n if N==1:\r\n C=L-1\r\n else:\r\n C=-(L-1)*16-(N-1)\r\n #print(\"C =\",C,end=' ')\r\n \r\n return struct.pack('b',C)","def calculate(self):","def generate_code(spn_id, spn, meta_types, floating_data_type):\r\n\r\n # make sure we have ids\r\n assign_ids(spn)\r\n\r\n # fill method body according to SPN structure\r\n method_body = generate_method_body(spn, spn, floating_data_type, 0)\r\n\r\n # build parameters used in generated c++ function\r\n method_params = []\r\n passed_params = []\r\n for i, type in enumerate(meta_types):\r\n if type == MetaType.DISCRETE:\r\n method_params += [f'vector <int> possibleValues{i}', f'int nullValueIdx{i}']\r\n passed_params += [f'py::arg(\"possibleValues{i}\")', f'py::arg(\"nullValueIdx{i}\")']\r\n elif type == MetaType.REAL:\r\n method_params += [f'bool inverse{i}', f'bool leftMinusInf{i}', f'float leftCondition{i}',\r\n f'bool rightMinusInf{i}', f'float rightCondition{i}', f'bool leftIncluded{i}',\r\n f'bool rightIncluded{i}', f'float nullValue{i}']\r\n passed_params += [f'py::arg(\"inverse{i}\")', f'py::arg(\"leftMinusInf{i}\")', f'py::arg(\"leftCondition{i}\")',\r\n f'py::arg(\"rightMinusInf{i}\")', f'py::arg(\"rightCondition{i}\")',\r\n f'py::arg(\"leftIncluded{i}\")', f'py::arg(\"rightIncluded{i}\")', f'py::arg(\"nullValue{i}\")']\r\n\r\n value_dictionary = {\r\n 'spn_id': spn_id,\r\n 'method_body': method_body,\r\n 'method_params': ', '.join(method_params),\r\n 'node_count': get_number_of_nodes(spn),\r\n 'passed_params': ', '.join(passed_params),\r\n 'floating_data_type': floating_data_type\r\n }\r\n generated_method = replace_template(TemplatePath.METHOD_MASTER, value_dictionary, 0)\r\n registrate_method = replace_template(TemplatePath.REGISTRATION_MASTER, value_dictionary, 0)\r\n\r\n return generated_method, registrate_method","def problem_48():\n\n return int(str(sum(x**x for x in range(1, 1001)))[-10:])","def function(self):\n return self.generator.module.neumannz","def valor(self):\n nbits = len(self.gens)\n dec = int(self.gens,2)\n real = self.min+dec*((self.max-self.min)/(math.pow(2,nbits)-1))\n return real","def gen_code(self, compile_unit):\n self.builder = irutils.Builder()\n self.ir_var_map = {}\n self.logger.debug(\"Generating IR-code\")\n self.debug_db = debuginfo.DebugDb()\n ir_mod = ir.Module(\"main\", debug_db=self.debug_db)\n self.builder.module = ir_mod\n\n # Split declaration into functions and variables:\n functions = []\n variables = []\n for declaration in compile_unit.declarations:\n assert isinstance(declaration, declarations.CDeclaration)\n\n if isinstance(\n declaration,\n (declarations.Typedef, declarations.EnumConstantDeclaration),\n ):\n pass\n elif isinstance(declaration, declarations.FunctionDeclaration):\n functions.append(declaration)\n elif isinstance(declaration, declarations.VariableDeclaration):\n variables.append(declaration)\n else: # pragma: no cover\n raise NotImplementedError(str(declaration))\n\n # Generate code:\n for variable in variables:\n self.gen_global_variable(variable)\n\n for function in functions:\n self.create_function(function)\n\n for function in functions:\n self.gen_function(function)\n\n self.logger.info(\"Finished IR-code generation\")\n return ir_mod","def NumericString_ (typecode, value) :\r\n if typecode == 'f' :\r\n return formatHelp_(\"%#.7G\", value)\r\n \r\n elif typecode == 'd' :\r\n return formatHelp_(\"%#.16G\", value)\r\n \r\n elif typecode == 'F' :\r\n front = '('+formatHelp_(\"%#.7G\", value.real, strip_all_zeros=True)\r\n if value.imag==0 :\r\n front += \"+0j)\"\r\n else :\r\n front += formatHelp_(\"%+#.7G\", value.imag, strip_all_zeros=True)+\"j)\"\r\n return front\r\n \r\n elif typecode == 'D' :\r\n front = '('+formatHelp_(\"%#.16G\", value.real, strip_all_zeros=True)\r\n if value.imag==0 :\r\n front += \"+0j)\"\r\n else :\r\n front += formatHelp_(\"%+#.16G\", value.imag, strip_all_zeros=True)+\"j)\"\r\n return front\r\n \r\n else :\r\n return str(value)","def calculate_exponent():\n pass","def numer(self, a):\n raise NotImplementedError","def genRate(self):\n\n # We need to compute normEsquared before we can compute the generation\n # rate\n normEsq = self.get_scalar_quantity('normEsquared')\n # Prefactor for generation rate. Note we gotta convert from m^3 to\n # cm^3, hence 1e6 factor\n fact = consts.epsilon_0 / (consts.hbar * 1e6)\n gvec = np.zeros_like(normEsq)\n # Main loop to compute generation in each layer\n freq = self.conf[('Simulation', 'params', 'frequency')]\n for name, layer in self.layers.items():\n self.log.debug('LAYER: %s', name)\n self.log.debug('LAYER T: %f', layer.thickness)\n self.log.debug('START: %f', layer.start)\n self.log.debug('END: %f', layer.end)\n # Use the layer object to get the nk matrix with correct material\n # geometry\n nmat, kmat = layer.get_nk_matrix(freq, self.X, self.Y)\n gvec[layer.get_slice(self.Z)] = fact * nmat * kmat * normEsq[layer.get_slice(self.Z)]\n # gvec[layer.get_slice()] = nmat * kmat * normEsq[layer.get_slice(self.Z)]\n self.extend_data('genRate', gvec)\n return gvec","def _rawprng(self):\n self.p += 1 \n if self.p >= self.o:\n\t\t\tself.p = 0\n t = 1768863 * self.s[self.p] + self.c * 2.3283064365386963e-10\n self.c = int(t) | 0\n self.s[self.p] = t - self.c\n return self.s[self.p]","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def generateCode(self, codeGenerator):\n return codeGenerator.generateCode(self)","def ccode(self):\n from devito.ir.iet.visitors import CGen\n return CGen().visit(self)","def get_fitness_function_c_code(self):\n s = \"\"\"FLOAT fitness_function(FLOAT phi, FLOAT chi, FLOAT omega)\n {\n FLOAT fitness = absolute(phi);\n return fitness;\n }\n \"\"\" \n return s","def get_fitness_function_c_code(self):\n s = \"\"\"FLOAT fitness_function(FLOAT phi, FLOAT chi, FLOAT omega)\n {\n FLOAT fitness = absolute(phi);\n return fitness;\n }\n \"\"\" \n return s","def create_code():\n\n code = [0, 0, 0, 0]\n\n for i in range(4):\n value = random.randint(1, 8) # 8 possible digits\n while value in code:\n value = random.randint(1, 8) # 8 possible digits\n code[i] = value\n \n #print(code)\n return code","def function(self):\n return self.generator.module.neumann","def genus(self):\n return 1 - self.euler_characteristic() // 2","def value(self):\n try: return 10.**(self._value)\n except AttributeError: raise GAError, 'gene not initialized'","def gm2code(arr, info):\n return (arr / info.pboxsize + 0.5)# * 0.999783599","def generate_code_implementation(name, code, comment=None):\n k = code.dimension()\n cs, _p = code.standard_form()\n info = {\n 'name': name,\n 'n': code.length(),\n 'k': k,\n 'generator': [bools_to_binvec(row) for row in cs.systematic_generator_matrix()],\n 'generator_bools': cs.systematic_generator_matrix(),\n 'parity_matrix': [bools_to_binvec(row) for row in cs.parity_check_matrix()],\n \"comment\": comment,\n }\n\n max_error = code.decoder().maximum_error_weight()\n\n syndrome_map = {}\n for (he, error) in cs.decoder().syndrome_table().items():\n syndrome_map[ZZ(list(he), base=2)] = bools_to_binvec(error)\n\n info['syndrome_map'] = syndrome_map\n info['syndrome_map_itemlen'] = len(list(syndrome_map.values())[0])\n\n assert max(syndrome_map) < 2**64, \"sydrome map too big!\"\n \n info['info_set'] = cs.information_set()\n\n testcases = []\n if 'might-error' in cs.decoder().decoder_type():\n max_error -= 3\n for _ in range(20):\n randvec = random_vector(GF(2), code.length())\n codeword = cs.decode_to_code(randvec)\n testcase = {\n 'randvec': randvec,\n 'codeword': codeword,\n }\n testcases.append(testcase)\n\n info['testcases'] = testcases\n\n with open('syndrome_code_implementation.rs.j2', 'r') as templatefile:\n template = ENVIRONMENT.from_string(templatefile.read())\n with open('{name}/{name}_{n}_{k}.rs'.format(name=name.lower(),\n n=code.length(), k=k),\n 'w') as outputfile:\n outputfile.write(template.render(**info))\n\n rendered_codes[name].append((code.length(), code.dimension()))","def generate(self):\n return self.gen.generate()","def typecode (self) :\r\n return self.numeric_typecode","def power_gen(k):\n if k == 0:\n return constant\n if k == 1:\n return identity\n @natural_input\n def power_k(n):\n return n ** k\n return power_k","def _numeric_jacobian(self):\n if self.__numeric_jacobian is None:\n self.__numeric_jacobian = self._lambdify(self._symbolic_jacobian)\n return self.__numeric_jacobian","def make_anonymous_factorial():\n return 'YOUR_EXPRESSION_HERE'","def make_anonymous_factorial():\n return 'YOUR_EXPRESSION_HERE'","def make_anonymous_factorial():\n return 'YOUR_EXPRESSION_HERE'","def make_anonymous_factorial():\n return 'YOUR_EXPRESSION_HERE'","def numer(self, a):\n return a","def generateCodeWithoutIndices(self, codeGenerator):\n return self.variable.generateCode(codeGenerator)","def generate(self):\n pass","def n():\n # For documentation purposes","def generate(self):\n start = self.nu_idx\n stop = start + self.score\n return self.orig_nu[start:stop]","def fortran_functions(self) -> str:\n fun_name = f'{self.f_prefix}_{self.name}_to_int_'\n result = f'integer function {fun_name}(flags)\\n'\n result += ' implicit none\\n'\n result += '\\n'\n result += f' class({self.f_prefix}_{self.name}), intent(in) :: flags\\n'\n result += ' integer :: ret_val\\n'\n result += '\\n'\n result += ' ret_val = 0\\n'\n for i, value in enumerate(self.values):\n result += f\" if (flags%{value}) ret_val = ret_val + {1 << i}\\n\"\n result += f' {fun_name} = ret_val\\n'\n result += f'end function {fun_name}\\n'\n return indent(result, 4*' ')","def generate(self):\n pass","def generate(self):\n pass"],"string":"[\n \"def code(self):\\n if not self._code:\\n filename = '<fluxtools function %s>' % self.tag\\n self._code = compile(self.math, filename, mode='eval')\\n return self._code\",\n \"def _get_random_number_code(self):\\r\\n return \\\"str(random.randint(0, 1e9))\\\"\",\n \"def number(self):\",\n \"def gen_code(self, filename, func_name):\\n\\n assert self.bits is not None\\n\\n vd_list = []\\n n_vars = 0\\n for tree in self.trees:\\n vd_list.append(tree.gen_code(n_vars))\\n n_vars += len(vd_list[-1])\\n\\n # checks the type by the suffix\\n\\n is_v = filename.split(\\\".\\\")[-1] == \\\"v\\\"\\n\\n assert self.inputs\\n\\n f = open(filename, \\\"w\\\")\\n\\n i_bits = np.sum(self.bits[:-1])\\n o_bits = self.bits[-1]\\n o_sign = self.is_neg[-1]\\n\\n if is_v:\\n f.write(\\\"module {}(input [{}:0] i, output [{}:0] o);\\\\n\\\".format(\\n func_name, i_bits-1, o_bits-1))\\n else:\\n f.write(\\\"#include<ac_int.h>\\\\n\\\\n\\\")\\n f.write(\\\"void {}(ac_int<{},false> i, ac_int<{},{}> &o)\\\\n\\\".format(\\n func_name, i_bits, o_bits, o_sign))\\n f.write(\\\"{\\\\n\\\")\\n\\n\\n # write function headline\\n s_in_line = []\\n\\n i_bits = self.bits[0]\\n i_sign = self.is_neg[0]\\n\\n if is_v:\\n i_datatype = \\\" wire {}[{}:0] \\\".format(\\n \\\"signed \\\" if i_sign else \\\"\\\", i_bits-1)\\n else:\\n i_datatype = \\\" ac_int<{},{}> \\\".format(i_bits, i_sign)\\n\\n len_s = len(i_datatype)\\n\\n for i in range(self.inputs):\\n if is_v:\\n s = (\\n \\\"i_\\\" + str(i) + \\\" = \\\" + \\\"i[\\\" + str(i_bits*(i+1)-1) + \\\":\\\" +\\n str(i_bits*i) + \\\"]\\\"\\n )\\n else:\\n s = (\\n \\\"i_\\\" + str(i) + \\\" = \\\" + \\\"i.slc<\\\" + str(i_bits) + \\\">(\\\" +\\n str(i_bits*i) + \\\")\\\"\\n )\\n if (\\n len_s + len(s) + 2 > 70 or i_bits != self.bits[i] or\\n i_sign != self.is_neg[i]\\n ):\\n f.write(i_datatype + \\\", \\\".join(s_in_line) + \\\";\\\\n\\\")\\n\\n s_in_line = []\\n if is_v:\\n i_datatype = \\\" wire {}[{}:0] \\\".format(\\n \\\"signed \\\" if i_sign else \\\"\\\", i_bits-1)\\n else:\\n i_datatype = \\\" ac_int<{},{}> \\\".format(i_bits, i_sign)\\n\\n len_s = len(i_datatype)\\n\\n s_in_line.append(s)\\n len_s += len(s) + 2\\n\\n if s_in_line:\\n f.write(i_datatype + \\\", \\\".join(s_in_line) + \\\";\\\\n\\\")\\n\\n if is_v:\\n o_datatype = \\\" wire {}[{}:0] \\\".format(\\n \\\"signed \\\" if o_sign else \\\"\\\", o_bits)\\n else:\\n o_datatype = \\\" ac_int<{},{}> \\\".format(o_bits, o_sign)\\n\\n o_list = []\\n for i in range(len(vd_list)):\\n for v in vd_list[i]:\\n if is_v:\\n f.write(o_datatype + v + \\\" = \\\" + vd_list[i][v] + \\\";\\\\n\\\")\\n else:\\n f.write(o_datatype + v + \\\" = \\\" + vd_list[i][v] + \\\";\\\\n\\\")\\n f.write(\\\"\\\\n\\\")\\n o_list.append(v)\\n\\n assert len(o_list) <= 3\\n\\n if is_v:\\n f.write(\\\" assign \\\")\\n else:\\n f.write(\\\" \\\")\\n\\n if len(o_list) == 1:\\n f.write(\\\"o = \\\" + o_list[0] + \\\";\\\")\\n elif len(o_list) == 2:\\n cond = \\\"( \\\" + o_list[0] + \\\" == \\\" + o_list[1] + \\\" ) \\\"\\n n1 = o_list[0]\\n n0 = \\\"( ( \\\" + \\\" + \\\".join(o_list) + \\\" ) >> 1 )\\\"\\n f.write(\\\"o = \\\" + cond + \\\"? \\\" + n1 + \\\": \\\" + n0)\\n elif len(o_list) == 3:\\n cond = (\\n \\\"( \\\" +\\n \\\"( \\\" + \\\" == \\\".join(o_list[0:2]) + \\\" )?\\\" + o_list[0] + \\\":\\\" +\\n \\\"( \\\" + \\\" == \\\".join(o_list[1:]) + \\\" )?\\\" + o_list[1] + \\\":\\\" +\\n \\\"( \\\" + \\\" == \\\".join([o_list[0], o_list[2]]) + \\\" )?\\\" + o_list[0] +\\n \\\":\\\" + \\\"( \\\" + \\\" < \\\".join(o_list[0:2]) + \\\" ) ?\\\" +\\n \\\"( ( \\\" + \\\" < \\\".join(o_list[1:]) + \\\" ) ?\\\" + o_list[1] + \\\":\\\" +\\n o_list[2] + \\\" ) : \\\" +\\n \\\"( ( \\\" + \\\" < \\\".join([o_list[0], o_list[2]]) + \\\" ) ?\\\" + o_list[0] +\\n \\\":\\\" + o_list[2] + \\\" )\\\"\\n )\\n f.write(\\\"o = \\\" + cond + \\\";\\\\n\\\")\\n if is_v:\\n f.write(\\\"endmodule\\\")\\n else:\\n f.write(\\\"}\\\")\\n\\n f.close()\",\n \"def nr():\\n pass\",\n \"def generation(x, g):\\n return int(x/g)\",\n \"def gen_numeric_literal(self, expr):\\n return self.emit_const(expr.value, expr.typ)\",\n \"def _gen_code(self):\\r\\n #TODO: maybe generate one C function only to save compile time? Also easier to take that as a basis and hand craft other covariances??\\r\\n\\r\\n #generate c functions from sympy objects \\r\\n argument_sequence = self._sp_x+self._sp_z+self._sp_theta\\r\\n code_list = [('k',self._sp_k)]\\r\\n # gradients with respect to covariance input\\r\\n code_list += [('dk_d%s'%x.name,dx) for x,dx in zip(self._sp_x,self._sp_dk_dx)]\\r\\n # gradient with respect to parameters\\r\\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta,self._sp_dk_dtheta)]\\r\\n # gradient with respect to multiple output parameters\\r\\n if self.output_dim > 1:\\r\\n argument_sequence += self._sp_theta_i + self._sp_theta_j\\r\\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta_i,self._sp_dk_dtheta_i)]\\r\\n (foo_c,self._function_code), (foo_h,self._function_header) = \\\\\\r\\n codegen(code_list, \\\"C\\\",'foobar',argument_sequence=argument_sequence)\\r\\n #put the header file where we can find it\\r\\n f = file(os.path.join(tempfile.gettempdir(),'foobar.h'),'w')\\r\\n f.write(self._function_header)\\r\\n f.close()\\r\\n\\r\\n # Substitute any known derivatives which sympy doesn't compute\\r\\n self._function_code = re.sub('DiracDelta\\\\(.+?,.+?\\\\)','0.0',self._function_code)\\r\\n\\r\\n\\r\\n ############################################################\\r\\n # This is the basic argument construction for the C code. #\\r\\n ############################################################\\r\\n \\r\\n arg_list = ([\\\"X2(i, %s)\\\"%x.name[2:] for x in self._sp_x]\\r\\n + [\\\"Z2(j, %s)\\\"%z.name[2:] for z in self._sp_z])\\r\\n\\r\\n # for multiple outputs need to also provide these arguments reversed.\\r\\n if self.output_dim>1:\\r\\n reverse_arg_list = list(arg_list)\\r\\n reverse_arg_list.reverse()\\r\\n\\r\\n # Add in any 'shared' parameters to the list.\\r\\n param_arg_list = [shared_params.name for shared_params in self._sp_theta]\\r\\n arg_list += param_arg_list\\r\\n\\r\\n precompute_list=[]\\r\\n if self.output_dim > 1:\\r\\n reverse_arg_list+=list(param_arg_list)\\r\\n split_param_arg_list = [\\\"%s1(%s)\\\"%(theta.name[:-2].upper(),index) for index in ['ii', 'jj'] for theta in self._sp_theta_i]\\r\\n split_param_reverse_arg_list = [\\\"%s1(%s)\\\"%(theta.name[:-2].upper(),index) for index in ['jj', 'ii'] for theta in self._sp_theta_i]\\r\\n arg_list += split_param_arg_list\\r\\n reverse_arg_list += split_param_reverse_arg_list\\r\\n # Extract the right output indices from the inputs.\\r\\n c_define_output_indices = [' '*16 + \\\"int %s=(int)%s(%s, %i);\\\"%(index, var, index2, self.input_dim-1) for index, var, index2 in zip(['ii', 'jj'], ['X2', 'Z2'], ['i', 'j'])]\\r\\n precompute_list += c_define_output_indices\\r\\n reverse_arg_string = \\\", \\\".join(reverse_arg_list)\\r\\n arg_string = \\\", \\\".join(arg_list)\\r\\n precompute_string = \\\"\\\\n\\\".join(precompute_list)\\r\\n\\r\\n # Code to compute argments string needed when only X is provided.\\r\\n X_arg_string = re.sub('Z','X',arg_string)\\r\\n # Code to compute argument string when only diagonal is required.\\r\\n diag_arg_string = re.sub('int jj','//int jj',X_arg_string)\\r\\n diag_arg_string = re.sub('j','i',diag_arg_string)\\r\\n if precompute_string == '':\\r\\n # if it's not multioutput, the precompute strings are set to zero\\r\\n diag_precompute_string = ''\\r\\n diag_precompute_replace = ''\\r\\n else:\\r\\n # for multioutput we need to extract the index of the output form the input.\\r\\n diag_precompute_string = precompute_list[0]\\r\\n diag_precompute_replace = precompute_list[1]\\r\\n \\r\\n\\r\\n # Here's the code to do the looping for K\\r\\n self._K_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _K_code\\r\\n // Code for computing the covariance function.\\r\\n int i;\\r\\n int j;\\r\\n int N = target_array->dimensions[0];\\r\\n int num_inducing = target_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N;i++){\\r\\n for (j=0;j<num_inducing;j++){\\r\\n%s\\r\\n //target[i*num_inducing+j] = \\r\\n TARGET2(i, j) += k(%s);\\r\\n }\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(precompute_string,arg_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n\\r\\n self._K_code_X = \\\"\\\"\\\"\\r\\n // _K_code_X\\r\\n // Code for computing the covariance function.\\r\\n int i;\\r\\n int j;\\r\\n int N = target_array->dimensions[0];\\r\\n int num_inducing = target_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N;i++){\\r\\n %s // int ii=(int)X2(i, 1);\\r\\n TARGET2(i, i) += k(%s);\\r\\n for (j=0;j<i;j++){\\r\\n %s //int jj=(int)X2(j, 1);\\r\\n double kval = k(%s); //double kval = k(X2(i, 0), shared_lengthscale, LENGTHSCALE1(ii), SCALE1(ii));\\r\\n TARGET2(i, j) += kval;\\r\\n TARGET2(j, i) += kval;\\r\\n }\\r\\n }\\r\\n /*%s*/\\r\\n \\\"\\\"\\\"%(diag_precompute_string, diag_arg_string, re.sub('Z2', 'X2', diag_precompute_replace), X_arg_string,str(self._sp_k)) #adding a string representation forces recompile when needed\\r\\n\\r\\n # Code to do the looping for Kdiag\\r\\n self._Kdiag_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _Kdiag_code\\r\\n // Code for computing diagonal of covariance function.\\r\\n int i;\\r\\n int N = target_array->dimensions[0];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for\\r\\n for (i=0;i<N;i++){\\r\\n %s\\r\\n //target[i] =\\r\\n TARGET1(i)=k(%s);\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(diag_precompute_string,diag_arg_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n\\r\\n # Code to compute gradients\\r\\n grad_func_list = []\\r\\n if self.output_dim>1:\\r\\n grad_func_list += c_define_output_indices\\r\\n grad_func_list += [' '*16 + 'TARGET1(%i+ii) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, arg_string) for i, theta in enumerate(self._sp_theta_i)]\\r\\n grad_func_list += [' '*16 + 'TARGET1(%i+jj) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, reverse_arg_string) for i, theta in enumerate(self._sp_theta_i)]\\r\\n grad_func_list += ([' '*16 + 'TARGET1(%i) += PARTIAL2(i, j)*dk_d%s(%s);'%(i,theta.name,arg_string) for i,theta in enumerate(self._sp_theta)])\\r\\n grad_func_string = '\\\\n'.join(grad_func_list) \\r\\n\\r\\n self._dK_dtheta_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dK_dtheta_code\\r\\n // Code for computing gradient of covariance with respect to parameters.\\r\\n int i;\\r\\n int j;\\r\\n int N = partial_array->dimensions[0];\\r\\n int num_inducing = partial_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N;i++){\\r\\n for (j=0;j<num_inducing;j++){\\r\\n%s\\r\\n }\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(grad_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") # adding a string representation forces recompile when needed\\r\\n\\r\\n\\r\\n # Code to compute gradients for Kdiag TODO: needs clean up\\r\\n diag_grad_func_string = re.sub('Z','X',grad_func_string,count=0)\\r\\n diag_grad_func_string = re.sub('int jj','//int jj',diag_grad_func_string)\\r\\n diag_grad_func_string = re.sub('j','i',diag_grad_func_string)\\r\\n diag_grad_func_string = re.sub('PARTIAL2\\\\(i, i\\\\)','PARTIAL1(i)',diag_grad_func_string)\\r\\n self._dKdiag_dtheta_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dKdiag_dtheta_code\\r\\n // Code for computing gradient of diagonal with respect to parameters.\\r\\n int i;\\r\\n int N = partial_array->dimensions[0];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n for (i=0;i<N;i++){\\r\\n %s\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(diag_grad_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n\\r\\n # Code for gradients wrt X, TODO: may need to deal with special case where one input is actually an output.\\r\\n gradX_func_list = []\\r\\n if self.output_dim>1:\\r\\n gradX_func_list += c_define_output_indices\\r\\n gradX_func_list += [\\\"TARGET2(i, %i) += PARTIAL2(i, j)*dk_dx_%i(%s);\\\"%(q,q,arg_string) for q in range(self._real_input_dim)]\\r\\n gradX_func_string = \\\"\\\\n\\\".join(gradX_func_list)\\r\\n\\r\\n self._dK_dX_code = \\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dK_dX_code\\r\\n // Code for computing gradient of covariance with respect to inputs.\\r\\n int i;\\r\\n int j;\\r\\n int N = partial_array->dimensions[0];\\r\\n int num_inducing = partial_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N; i++){\\r\\n for (j=0; j<num_inducing; j++){\\r\\n %s\\r\\n }\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(gradX_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n \\r\\n\\r\\n diag_gradX_func_string = re.sub('Z','X',gradX_func_string,count=0)\\r\\n diag_gradX_func_string = re.sub('int jj','//int jj',diag_gradX_func_string)\\r\\n diag_gradX_func_string = re.sub('j','i',diag_gradX_func_string)\\r\\n diag_gradX_func_string = re.sub('PARTIAL2\\\\(i, i\\\\)','2*PARTIAL1(i)',diag_gradX_func_string)\\r\\n\\r\\n # Code for gradients of Kdiag wrt X\\r\\n self._dKdiag_dX_code= \\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dKdiag_dX_code\\r\\n // Code for computing gradient of diagonal with respect to inputs.\\r\\n int N = partial_array->dimensions[0];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n for (int i=0;i<N; i++){\\r\\n %s\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(diag_gradX_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a\\r\\n # string representation forces recompile when needed Get rid\\r\\n # of Zs in argument for diagonal. TODO: Why wasn't\\r\\n # diag_func_string called here? Need to check that.\\r\\n #self._dKdiag_dX_code = self._dKdiag_dX_code.replace('Z[j', 'X[i')\\r\\n\\r\\n # Code to use when only X is provided. \\r\\n self._dK_dtheta_code_X = self._dK_dtheta_code.replace('Z[', 'X[')\\r\\n self._dK_dX_code_X = self._dK_dX_code.replace('Z[', 'X[').replace('+= PARTIAL2(', '+= 2*PARTIAL2(') \\r\\n self._dK_dtheta_code_X = self._dK_dtheta_code_X.replace('Z2(', 'X2(')\\r\\n self._dK_dX_code_X = self._dK_dX_code_X.replace('Z2(', 'X2(')\\r\\n\\r\\n\\r\\n #TODO: insert multiple functions here via string manipulation\\r\\n #TODO: similar functions for psi_stats\\r\",\n \"def numerize():\\n pass\",\n \"def numeric(*args):\",\n \"def generate_cpp():\\n cpp_file = AUTOGEN_WARNING\\n cpp_file += \\\"// Implements basic nuclear data functions.\\\\n\\\"\\n cpp_file += \\\"#ifndef PYNE_IS_AMALGAMATED\\\\n\\\"\\n cpp_file += '#include \\\"atomic_data.h\\\"\\\\n'\\n cpp_file += '#include \\\"nucname.h\\\"\\\\n'\\n cpp_file += \\\"#endif\\\\n\\\"\\n cpp_file += \\\" \\\\n\\\"\\n cpp_file += \\\"void pyne::_load_atomic_mass_map_memory() { \\\\n\\\"\\n cpp_file += \\\" // header version of atomic weight table data \\\\n\\\"\\n cpp_file += \\\" //see if the data table is already loaded\\\\n\\\"\\n cpp_file += \\\" if(!atomic_mass_map.empty()) {\\\\n\\\"\\n cpp_file += \\\" return;\\\\n\\\"\\n cpp_file += \\\" } else { \\\\n\\\"\\n cpp_file += \\\" _insert_atomic_mass_map();\\\\n\\\"\\n cpp_file += \\\" }\\\\n\\\"\\n cpp_file += \\\" //see if the data table is already loaded\\\\n\\\"\\n cpp_file += \\\" if(!natural_abund_map.empty()) {\\\\n\\\"\\n cpp_file += \\\" return;\\\\n\\\"\\n cpp_file += \\\" } else { \\\\n\\\"\\n cpp_file += \\\" _insert_abund_map();\\\\n\\\"\\n cpp_file += \\\" }\\\\n\\\"\\n cpp_file += \\\" // calculate the atomic_masses of the elements \\\\n\\\"\\n cpp_file += \\\" std::map<int,double> :: iterator it;\\\\n\\\"\\n cpp_file += \\\" \\\\n\\\"\\n cpp_file += \\\" for (int z = 1; z <= 92 ; z++) {\\\\n\\\"\\n cpp_file += \\\" // loop through the natural abundance map\\\\n\\\"\\n cpp_file += \\\" double element_atomic_weight = 0.0;\\\\n\\\"\\n cpp_file += \\\" for (it = natural_abund_map.begin(); it != natural_abund_map.end() ; ++it){\\\\n\\\"\\n cpp_file += \\\" // if the atomic number of the abudance matches the\\\\n\\\"\\n cpp_file += \\\" // that of index\\\\n\\\"\\n cpp_file += \\\" if(pyne::nucname::znum(it->first) == z) {\\\\n\\\"\\n cpp_file += \\\" // take atomic abundance and multiply by mass\\\\n\\\"\\n cpp_file += (\\n \\\" // to get the mass of that nuclide / 100 since abundance is in %\\\\n\\\"\\n )\\n cpp_file += \\\" element_atomic_weight += (it->second*atomic_mass_map[it->first]/100.0);\\\\n\\\"\\n cpp_file += \\\" }\\\\n\\\"\\n cpp_file += \\\" }\\\\n\\\"\\n cpp_file += \\\" // insert the abundance of the element into the list\\\\n\\\"\\n cpp_file += \\\" atomic_mass_map[z*10000000] = element_atomic_weight;\\\\n\\\"\\n cpp_file += \\\" }\\\\n\\\"\\n cpp_file += \\\"}\\\\n\\\"\\n cpp_file += \\\"\\\\n\\\\n\\\"\\n cpp_file += \\\"void pyne::_insert_atomic_mass_map() { \\\\n\\\"\\n cpp_file += generate_atomic_mass()\\n cpp_file += \\\"}\\\\n\\\"\\n cpp_file += \\\"\\\\n\\\\n\\\"\\n cpp_file += \\\"void pyne::_insert_abund_map() { \\\\n\\\"\\n cpp_file += generate_abundances()\\n cpp_file += \\\"}\\\\n\\\"\\n return cpp_file\",\n \"def generate():\",\n \"def genCode(self):\\n # Init variables and environment.\\n if 'Sys' in self.inputs:\\n self.cg_bootstrap_sys()\\n\\n for ns, vm_code in self.inputs.items():\\n input = Parser(vm_code).parse()\\n self.ns = ns\\n\\n if input['errors']:\\n # No meaningful output can be generated.\\n # Print errors to stderr and return empty string.\\n print(\\\"ERRORS\\\", file=sys.stderr)\\n for err in input['errors']:\\n print(\\\"Line {}: {}\\\".format(err.line, err.msg))\\n return f\\\"// Encountered errors parsing {filename}\\\"\\n\\n # Translate input.\\n self.asm(f\\\"// Input file: {ns}\\\")\\n for cmd in input['commands']:\\n # Print original VM command as a comment.\\n self.asm('// ' + cmd.src)\\n self.cg(cmd)\\n self.asm(f\\\"// End of input file: {ns}\\\")\\n\\n # Add the stop loop.\\n self.cg_stop()\\n\\n return '\\\\n'.join(self.text)\",\n \"def curve_number(self):\",\n \"def v_numeric(self, **kwargs):\\n self.system.groups['StaticGen'].set(src='u', idx=self.gen.v, attr='v', value=0)\",\n \"def getNumber():\",\n \"def gen_code():\\n return ''.join([random.choice(string.ascii_uppercase + string.digits) for _ in range(10)])\",\n \"def generate(self):\\n tempSn_1 = self.sn_1\\n self.sn_1 = (self.an_2*self.sn_2 + self.an_1*self.sn_1) % self.mod\\n self.sn_2 = tempSn_1\\n return self.sn_1 / self.mod\",\n \"def main():\\n result = 0\\n for n in range(1, 1001):\\n result += n**n\\n\\n result = str(result)\\n answer = result[len(result)-10::]\\n\\n print \\\"answer: \\\" + answer\",\n \"def generate_swift_code(self, num):\\n swift_code = []\\n for _ in range(num):\\n swift_code.append(self.fake.swift())\\n return swift_code\",\n \"def gencode(self):\\n\\n fullcode = self.code_cfg\\n variables = codeconfig_getvars(fullcode)\\n if len(variables) > 0:\\n variables.sort(key=lambda x: len(x), reverse=True)\\n for va in variables:\\n if eval(\\\"self.\\\" + va[1:]) is None or eval(\\\"self.\\\" + va[1:]) == \\\"\\\":\\n warnings.warn(\\\"Inserting None for \\\" + va, UserWarning)\\n fullcode = fullcode.replace(va, str(eval(\\\"self.\\\" + va[1:])))\\n # testing for sintax errors\\n #compile(fullcode, \\\"<Test ModelCall Code>\\\\n\\\" + fullcode, 'exec')\\n tmpfile = os.path.join(gettempdir(), \\\"TestModelCallCode.\\\" + self.complexity + \\\".py\\\")\\n with open(tmpfile, \\\"w\\\") as f: f.write(fullcode)\\n compile(fullcode, tmpfile, 'exec')\\n return fullcode\",\n \"def code():\",\n \"def test_numbers(self):\\n \\n result = gen_expansion(sym.pi, 2)\\n self.assertEqual(result, '14')\\n result = gen_expansion(sym.exp(1), 2)\\n self.assertEqual(result, '72')\",\n \"def evaluate(self) -> int:\",\n \"def _pettifor_numbers():\\n return { \\\"Li\\\": 0.45,\\n \\\"Be\\\": 1.5,\\n \\\"B\\\": 2.0,\\n \\\"C\\\": 2.5,\\n \\\"N\\\": 3.0, \\n \\\"O\\\": 3.5,\\n \\\"F\\\": 4.0,\\n \\n \\\"Na\\\": 0.4,\\n \\\"Mg\\\": 1.28,\\n \\\"Al\\\": 1.66,\\n \\\"Si\\\": 1.92,\\n \\\"P\\\": 2.18,\\n \\\"S\\\": 2.44,\\n \\\"Cl\\\": 2.70,\\n \\n \\\"K\\\": 0.35,\\n \\\"Ca\\\": 0.60,\\n \\\"Sc\\\": 0.74,\\n \\\"Ti\\\": 0.79,\\n \\\"V\\\": 0.84,\\n \\\"Cr\\\": 0.89,\\n \\\"Mn\\\": 0.94,\\n \\\"Fe\\\": 0.99,\\n \\\"Co\\\": 1.04,\\n \\\"Ni\\\": 1.09,\\n \\\"Cu\\\": 1.20,\\n \\\"Zn\\\": 1.44,\\n \\\"Ga\\\": 1.68,\\n \\\"Ge\\\": 1.92,\\n \\\"As\\\": 2.16,\\n \\\"Se\\\": 2.40,\\n \\\"Br\\\": 2.64,\\n\\n \\\"Rb\\\": 0.30,\\n \\\"Sr\\\": 0.55,\\n \\\"Y\\\": 0.70,\\n \\\"Zr\\\": 0.76,\\n \\\"Nb\\\": 0.82,\\n \\\"Mo\\\": 0.88,\\n \\\"Tc\\\": 0.94,\\n \\\"Ru\\\": 1.00,\\n \\\"Rh\\\": 1.06,\\n \\\"Pd\\\": 1.12,\\n \\\"Ag\\\": 1.18,\\n \\\"Cd\\\": 1.36,\\n \\\"In\\\": 1.60,\\n \\\"Sn\\\": 1.84,\\n \\\"Sb\\\": 2.08,\\n \\\"Te\\\": 2.32,\\n \\\"I\\\": 2.56,\\n \\n \\\"Cs\\\": 0.25,\\n \\\"Ba\\\": 0.50,\\n \\\"La\\\": 0.748,\\n \\\"Hf\\\": 0.775,\\n \\\"Ta\\\": 0.83,\\n \\\"W\\\": 0.885,\\n \\\"Re\\\": 0.94,\\n \\\"Os\\\": 0.995,\\n \\\"Ir\\\": 1.05,\\n \\\"Pt\\\": 1.105,\\n \\\"Au\\\": 1.16,\\n \\\"Hg\\\": 1.32,\\n \\\"Tl\\\": 1.56,\\n \\\"Pb\\\": 1.80,\\n \\\"Bi\\\": 2.04,\\n \\\"Po\\\": 2.28, \\n \\\"At\\\": 2.52 }\",\n \"def Mo96(self,dc,nu):\\n return 1. + (nu**2.-1.)/dc\",\n \"def _generate_code_blocks(self):\\n\\n printer = self._generate_pydy_c_printer()()\\n\\n self.code_blocks = {}\\n\\n lines = []\\n for i, input_arg in enumerate(self.arguments):\\n lines.append('double input_{}[{}],'.format(i, len(input_arg)))\\n self.code_blocks['input_args'] = wrap_and_indent(lines, 14)\\n\\n lines = []\\n for i, output_arg in enumerate(self.matrices):\\n nr, nc = output_arg.shape\\n lines.append('double output_{}[{}],'.format(i, nr * nc))\\n self.code_blocks['output_args'] = \\\\\\n wrap_and_indent(lines, 14)[:-1] # remove last comma\\n\\n lines = []\\n for i, (input_arg, explan) in enumerate(zip(self.arguments,\\n self.comma_lists())):\\n lines.append('input_{}[{}] : [{}]'.format(i, len(input_arg),\\n explan))\\n self.code_blocks['input_docstring'] = wrap_and_indent(lines, 0)\\n\\n lines = []\\n for var, expr in self.subexprs:\\n var_str = printer.doprint(var)\\n expr_str = printer.doprint(expr)\\n lines.append('double {} = {};'.format(var_str, expr_str))\\n self.code_blocks['subexprs'] = wrap_and_indent(lines)\\n\\n outputs = ''\\n for i, output in enumerate(self.simplified_matrices):\\n nr, nc = output.shape\\n lhs = sm.MatrixSymbol('output_{}'.format(i), nr, nc)\\n try:\\n code_str = printer.doprint(output, lhs)\\n except AttributeError:\\n # The above fails in SymPy 0.7.4.1 because Matrix printing\\n # isn't supported.\\n code_lines = []\\n for j, element in enumerate(output):\\n assignment = 'output_{}[{}]'.format(i, j)\\n code_lines.append(printer.doprint(element, assignment))\\n code_str = '\\\\n'.join(code_lines)\\n outputs += wrap_and_indent(code_str.split('\\\\n'))\\n if i != len(self.simplified_matrices) - 1:\\n outputs += '\\\\n\\\\n' # space between each output\\n\\n self.code_blocks['outputs'] = outputs\",\n \"def main():\\n for i in range(11):\\n i = i / 10\\n print('L * 1000', i, L(i) * 1000)\",\n \"def data_generation():\\n num1 = random.randint(1, 100)\\n num2 = random.randint(1, 100)\\n correct_answer = math.gcd(num1, num2)\\n expression = f'{num1} {num2}'\\n return expression, str(correct_answer)\",\n \"def code_str(self, fn_name):\\n code = CodeWriter()\\n code.wl(\\\"def \\\" + fn_name + \\\"(y):\\\")\\n code.inc_indent()\\n if self.m == 1:\\n code.wl(\\\"x = \\\" + str(self._a) + \\\" * y + \\\" + str(self._b))\\n else:\\n code.wl(\\\"a = np.\\\" + self._a.__repr__())\\n code.wl(\\\"b = np.\\\" + self._b.__repr__())\\n code.wl(\\\"x = np.dot(a, y) + b\\\")\\n poly_eval_code = self._unit_simplex_polynomial.code_str(\\\"temp\\\")\\n poly_eval_code = poly_eval_code.split('\\\\n')[1:]\\n poly_eval_code = \\\"\\\\n\\\".join(poly_eval_code)\\n code.verbatim(poly_eval_code)\\n code.dec_indent()\\n return code.code\",\n \"def generate(bits):\\r\\n raise NotImplementedError()\",\n \"def _generate_code(x, functional):\\n\\n printer = sympy.printing.lambdarepr.PythonCodePrinter()\\n\\n code = \\\"def evaluate(values, solution):\\\\n\\\"\\n code += \\\"\\\\tfor k in range(len(values)):\\\\n\\\"\\n code += \\\"\\\\t\\\\t\\\" + \\\", \\\".join(str(state) for state in x) + \\\" = solution[k]\\\\n\\\"\\n code += f\\\"\\\\t\\\\tvalues[k] = {printer.doprint(functional.evalf())}\\\\n\\\"\\n return code\",\n \"def generate(self):\",\n \"def code() -> str:\\n return \\\"\\\"\\\"\\n G91 G17\\n G0 Y10 X-10\\n G0 Y0 X-5\\n G0 Y5 X0\\n G0 Y0 X5\\n G0 Y0 X-5\\n G0 Y-5 X0\\n G3 Y-5 X5 J0 I5\\n G0 Y0 X5\\n G0 Y5 X0\\n G3 Y5 X-5 J0 I-5\\n G0 Y-5 X0\\n G0 Y-10 X10\\n G0 Y0 X-5\\n G0 Y-15 X-15\\n G0 Y0 X5\\n G0 Y5 X0\\n G0 Y0 X-5\\n G0 Y-5 X0\\n G0 Y5 X0\\n G2 Y5 X5 J0 I5\\n G0 Y0 X5\\n G0 Y-5 X0\\n G2 Y-5 X-5 J0 I-5\\n G0 Y5 X0\\n G0 Y10 X10\\n G0 Y0 X-30\\n G3 Y0 X-10 J0 I-5\\n G3 Y0 X10 J0 I5\\n\\n G0 Y0 X5\\n G3 Y5 X5 J5 I0\\n G3 Y10 X-10 J0 I-10\\n G3 Y-5 X-5 J-5 I0\\n G0 Y-5 X0\\n\\n G0 Y5 X0\\n G3 Y5 X-5 J0 I-5\\n G3 Y-10 X-10 J-10 I0\\n G3 Y-5 X5 J0 I5\\n G0 Y0 X5\\n\\n G0 Y0 X-5\\n G3 Y-5 X-5 J-5 I0\\n G3 Y-10 X10 J0 I10\\n G3 Y5 X5 J5 I0\\n G0 Y5 X0\\n\\n G0 Y-5 X0\\n G3 Y-5 X5 J0 I5\\n G3 Y10 X10 J10 I0\\n G3 Y5 X-5 J0 I-5\\n G0 Y0 X-5\\n \\\"\\\"\\\"\",\n \"def calculate(self):\\n\\n outs = map(str, map(self.translate, self.nums))\\n result = \\\"\\\\n\\\".join(outs)\\n\\n return str(result)\",\n \"def test_generate_nb(self):\\n pass\",\n \"def __math__(inputs: list) -> str:\\n # TODO: Find new way of indicating that a variable should be used instead of a static value.\\n\\n out = \\\"\\\"\\n if len(inputs) < 2:\\n return None # TODO: create error and throw that instead\\n fname, func = inspect.getmembers(math, inspect.isbuiltin)[inputs[0]]\\n out += fname + \\\"(\\\"\\n nvars = MachineInterface.__math_doc_nvars__(func.__doc__)\\n if nvars == 1:\\n out += str(inputs[1]) + \\\",\\\"\\n else:\\n for i in range(1, nvars):\\n out += str(inputs[i % len(inputs)]) + \\\",\\\"\\n\\n return out[:-1] + \\\")\\\"\\n # b = func.__doc__\\n # print(dir(func))\\n # print(b)\\n # print(dir(b))\\n # print(inspect.signature(b)\",\n \"def code_format(self):\\n return \\\"^\\\\\\\\d{%s}$\\\" % self._digits\",\n \"def make_g_number():\\n return fake.bothify(text='??#########')\",\n \"def y(self) -> int:\",\n \"def GenerateCode(self):\\n print \\\"Generating code...\\\"\\n for type in self.getObjectTypes():\\n generator = __import__(\\\"codegen.Cpp\\\" + type, globals(), locals(), [''])\\n print \\\"Generating code for objects of type: %s\\\" % type\\n generator.GenerateCode(self)\",\n \"def function(self):\\n return self.generator.module.neumannx\",\n \"def random_num(self):\\r\\n self.generate_n1()\\r\\n self.generate_n2()\\r\\n self.generate_n3()\\r\\n self.generate_n4()\\r\\n random_number = str(self.n_1decimal)+str(self.n_2decimal)+str(self.n_3decimal)+str(self.n_4decimal)\\r\\n print int(random_number)\",\n \"def generate_new_code():\\n code = ''.join(random.choice(string.digits) for i in range(6))\\n return code\",\n \"def GenerateNormalExpression(n):\\n if int(n) != n or n < 1:\\n return None\\n return '+'.join(['a[%d]' % ii for ii in range(n)])\",\n \"def make_code(self, datasetname):\\n try:\\n if(datasetname):\\n for i in range(1, len(self.extract()) + 1):\\n self.formated = datasetname + \\\"%03d\\\" % (i,)\\n yield self.formated \\n except:\\n raise\",\n \"def NACA4digitsSym(self):\\n self.ytu = self.NacaEquation(self.xu,self.t)\\n self.ytl = -self.NacaEquation(self.xl,self.t)\\n # Done for estitic reasons\\n self.yu = self.ytu \\n self.yl = self.ytl\\n self.z = np.concatenate((self.yu, np.flip(self.yl)))\\n if self.plot:\\n plt.figure(self.name)\\n plt.title(self.name)\\n plt.plot(self.xu,self.yu)\\n plt.plot(self.xl,self.yl)\\n plt.axis('equal')\",\n \"def generate(self):\\r\\n raise NotImplementedError\",\n \"def generate_code(model, dataloader, code_length, device):\\n model.eval()\\n with torch.no_grad():\\n N = len(dataloader.dataset)\\n code = torch.zeros([N, code_length])\\n for data, _, index in dataloader:\\n data = data.to(device)\\n hash_code = model(data)\\n code[index, :] = hash_code.sign().cpu()\\n\\n model.train()\\n return code\",\n \"def gen_amounts(no_cultures):\\n # Init amounts\\n C = 0.01\\n N = 1.0\\n S = 0.0\\n init_amounts = np.array([C, N, S]*no_cultures)\\n return init_amounts\",\n \"def calculate_output(self):\",\n \"def Codingfunc(N,L): #Coding:[N:number of repetitions, L:length of single/multiple sequence]\\r\\n C=0 #int variable containing code number\\r\\n if N==1:\\r\\n C=L-1\\r\\n else:\\r\\n C=-(L-1)*16-(N-1)\\r\\n #print(\\\"C =\\\",C,end=' ')\\r\\n \\r\\n return struct.pack('b',C)\",\n \"def calculate(self):\",\n \"def generate_code(spn_id, spn, meta_types, floating_data_type):\\r\\n\\r\\n # make sure we have ids\\r\\n assign_ids(spn)\\r\\n\\r\\n # fill method body according to SPN structure\\r\\n method_body = generate_method_body(spn, spn, floating_data_type, 0)\\r\\n\\r\\n # build parameters used in generated c++ function\\r\\n method_params = []\\r\\n passed_params = []\\r\\n for i, type in enumerate(meta_types):\\r\\n if type == MetaType.DISCRETE:\\r\\n method_params += [f'vector <int> possibleValues{i}', f'int nullValueIdx{i}']\\r\\n passed_params += [f'py::arg(\\\"possibleValues{i}\\\")', f'py::arg(\\\"nullValueIdx{i}\\\")']\\r\\n elif type == MetaType.REAL:\\r\\n method_params += [f'bool inverse{i}', f'bool leftMinusInf{i}', f'float leftCondition{i}',\\r\\n f'bool rightMinusInf{i}', f'float rightCondition{i}', f'bool leftIncluded{i}',\\r\\n f'bool rightIncluded{i}', f'float nullValue{i}']\\r\\n passed_params += [f'py::arg(\\\"inverse{i}\\\")', f'py::arg(\\\"leftMinusInf{i}\\\")', f'py::arg(\\\"leftCondition{i}\\\")',\\r\\n f'py::arg(\\\"rightMinusInf{i}\\\")', f'py::arg(\\\"rightCondition{i}\\\")',\\r\\n f'py::arg(\\\"leftIncluded{i}\\\")', f'py::arg(\\\"rightIncluded{i}\\\")', f'py::arg(\\\"nullValue{i}\\\")']\\r\\n\\r\\n value_dictionary = {\\r\\n 'spn_id': spn_id,\\r\\n 'method_body': method_body,\\r\\n 'method_params': ', '.join(method_params),\\r\\n 'node_count': get_number_of_nodes(spn),\\r\\n 'passed_params': ', '.join(passed_params),\\r\\n 'floating_data_type': floating_data_type\\r\\n }\\r\\n generated_method = replace_template(TemplatePath.METHOD_MASTER, value_dictionary, 0)\\r\\n registrate_method = replace_template(TemplatePath.REGISTRATION_MASTER, value_dictionary, 0)\\r\\n\\r\\n return generated_method, registrate_method\",\n \"def problem_48():\\n\\n return int(str(sum(x**x for x in range(1, 1001)))[-10:])\",\n \"def function(self):\\n return self.generator.module.neumannz\",\n \"def valor(self):\\n nbits = len(self.gens)\\n dec = int(self.gens,2)\\n real = self.min+dec*((self.max-self.min)/(math.pow(2,nbits)-1))\\n return real\",\n \"def gen_code(self, compile_unit):\\n self.builder = irutils.Builder()\\n self.ir_var_map = {}\\n self.logger.debug(\\\"Generating IR-code\\\")\\n self.debug_db = debuginfo.DebugDb()\\n ir_mod = ir.Module(\\\"main\\\", debug_db=self.debug_db)\\n self.builder.module = ir_mod\\n\\n # Split declaration into functions and variables:\\n functions = []\\n variables = []\\n for declaration in compile_unit.declarations:\\n assert isinstance(declaration, declarations.CDeclaration)\\n\\n if isinstance(\\n declaration,\\n (declarations.Typedef, declarations.EnumConstantDeclaration),\\n ):\\n pass\\n elif isinstance(declaration, declarations.FunctionDeclaration):\\n functions.append(declaration)\\n elif isinstance(declaration, declarations.VariableDeclaration):\\n variables.append(declaration)\\n else: # pragma: no cover\\n raise NotImplementedError(str(declaration))\\n\\n # Generate code:\\n for variable in variables:\\n self.gen_global_variable(variable)\\n\\n for function in functions:\\n self.create_function(function)\\n\\n for function in functions:\\n self.gen_function(function)\\n\\n self.logger.info(\\\"Finished IR-code generation\\\")\\n return ir_mod\",\n \"def NumericString_ (typecode, value) :\\r\\n if typecode == 'f' :\\r\\n return formatHelp_(\\\"%#.7G\\\", value)\\r\\n \\r\\n elif typecode == 'd' :\\r\\n return formatHelp_(\\\"%#.16G\\\", value)\\r\\n \\r\\n elif typecode == 'F' :\\r\\n front = '('+formatHelp_(\\\"%#.7G\\\", value.real, strip_all_zeros=True)\\r\\n if value.imag==0 :\\r\\n front += \\\"+0j)\\\"\\r\\n else :\\r\\n front += formatHelp_(\\\"%+#.7G\\\", value.imag, strip_all_zeros=True)+\\\"j)\\\"\\r\\n return front\\r\\n \\r\\n elif typecode == 'D' :\\r\\n front = '('+formatHelp_(\\\"%#.16G\\\", value.real, strip_all_zeros=True)\\r\\n if value.imag==0 :\\r\\n front += \\\"+0j)\\\"\\r\\n else :\\r\\n front += formatHelp_(\\\"%+#.16G\\\", value.imag, strip_all_zeros=True)+\\\"j)\\\"\\r\\n return front\\r\\n \\r\\n else :\\r\\n return str(value)\",\n \"def calculate_exponent():\\n pass\",\n \"def numer(self, a):\\n raise NotImplementedError\",\n \"def genRate(self):\\n\\n # We need to compute normEsquared before we can compute the generation\\n # rate\\n normEsq = self.get_scalar_quantity('normEsquared')\\n # Prefactor for generation rate. Note we gotta convert from m^3 to\\n # cm^3, hence 1e6 factor\\n fact = consts.epsilon_0 / (consts.hbar * 1e6)\\n gvec = np.zeros_like(normEsq)\\n # Main loop to compute generation in each layer\\n freq = self.conf[('Simulation', 'params', 'frequency')]\\n for name, layer in self.layers.items():\\n self.log.debug('LAYER: %s', name)\\n self.log.debug('LAYER T: %f', layer.thickness)\\n self.log.debug('START: %f', layer.start)\\n self.log.debug('END: %f', layer.end)\\n # Use the layer object to get the nk matrix with correct material\\n # geometry\\n nmat, kmat = layer.get_nk_matrix(freq, self.X, self.Y)\\n gvec[layer.get_slice(self.Z)] = fact * nmat * kmat * normEsq[layer.get_slice(self.Z)]\\n # gvec[layer.get_slice()] = nmat * kmat * normEsq[layer.get_slice(self.Z)]\\n self.extend_data('genRate', gvec)\\n return gvec\",\n \"def _rawprng(self):\\n self.p += 1 \\n if self.p >= self.o:\\n\\t\\t\\tself.p = 0\\n t = 1768863 * self.s[self.p] + self.c * 2.3283064365386963e-10\\n self.c = int(t) | 0\\n self.s[self.p] = t - self.c\\n return self.s[self.p]\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def generateCode(self, codeGenerator):\\n return codeGenerator.generateCode(self)\",\n \"def ccode(self):\\n from devito.ir.iet.visitors import CGen\\n return CGen().visit(self)\",\n \"def get_fitness_function_c_code(self):\\n s = \\\"\\\"\\\"FLOAT fitness_function(FLOAT phi, FLOAT chi, FLOAT omega)\\n {\\n FLOAT fitness = absolute(phi);\\n return fitness;\\n }\\n \\\"\\\"\\\" \\n return s\",\n \"def get_fitness_function_c_code(self):\\n s = \\\"\\\"\\\"FLOAT fitness_function(FLOAT phi, FLOAT chi, FLOAT omega)\\n {\\n FLOAT fitness = absolute(phi);\\n return fitness;\\n }\\n \\\"\\\"\\\" \\n return s\",\n \"def create_code():\\n\\n code = [0, 0, 0, 0]\\n\\n for i in range(4):\\n value = random.randint(1, 8) # 8 possible digits\\n while value in code:\\n value = random.randint(1, 8) # 8 possible digits\\n code[i] = value\\n \\n #print(code)\\n return code\",\n \"def function(self):\\n return self.generator.module.neumann\",\n \"def genus(self):\\n return 1 - self.euler_characteristic() // 2\",\n \"def value(self):\\n try: return 10.**(self._value)\\n except AttributeError: raise GAError, 'gene not initialized'\",\n \"def gm2code(arr, info):\\n return (arr / info.pboxsize + 0.5)# * 0.999783599\",\n \"def generate_code_implementation(name, code, comment=None):\\n k = code.dimension()\\n cs, _p = code.standard_form()\\n info = {\\n 'name': name,\\n 'n': code.length(),\\n 'k': k,\\n 'generator': [bools_to_binvec(row) for row in cs.systematic_generator_matrix()],\\n 'generator_bools': cs.systematic_generator_matrix(),\\n 'parity_matrix': [bools_to_binvec(row) for row in cs.parity_check_matrix()],\\n \\\"comment\\\": comment,\\n }\\n\\n max_error = code.decoder().maximum_error_weight()\\n\\n syndrome_map = {}\\n for (he, error) in cs.decoder().syndrome_table().items():\\n syndrome_map[ZZ(list(he), base=2)] = bools_to_binvec(error)\\n\\n info['syndrome_map'] = syndrome_map\\n info['syndrome_map_itemlen'] = len(list(syndrome_map.values())[0])\\n\\n assert max(syndrome_map) < 2**64, \\\"sydrome map too big!\\\"\\n \\n info['info_set'] = cs.information_set()\\n\\n testcases = []\\n if 'might-error' in cs.decoder().decoder_type():\\n max_error -= 3\\n for _ in range(20):\\n randvec = random_vector(GF(2), code.length())\\n codeword = cs.decode_to_code(randvec)\\n testcase = {\\n 'randvec': randvec,\\n 'codeword': codeword,\\n }\\n testcases.append(testcase)\\n\\n info['testcases'] = testcases\\n\\n with open('syndrome_code_implementation.rs.j2', 'r') as templatefile:\\n template = ENVIRONMENT.from_string(templatefile.read())\\n with open('{name}/{name}_{n}_{k}.rs'.format(name=name.lower(),\\n n=code.length(), k=k),\\n 'w') as outputfile:\\n outputfile.write(template.render(**info))\\n\\n rendered_codes[name].append((code.length(), code.dimension()))\",\n \"def generate(self):\\n return self.gen.generate()\",\n \"def typecode (self) :\\r\\n return self.numeric_typecode\",\n \"def power_gen(k):\\n if k == 0:\\n return constant\\n if k == 1:\\n return identity\\n @natural_input\\n def power_k(n):\\n return n ** k\\n return power_k\",\n \"def _numeric_jacobian(self):\\n if self.__numeric_jacobian is None:\\n self.__numeric_jacobian = self._lambdify(self._symbolic_jacobian)\\n return self.__numeric_jacobian\",\n \"def make_anonymous_factorial():\\n return 'YOUR_EXPRESSION_HERE'\",\n \"def make_anonymous_factorial():\\n return 'YOUR_EXPRESSION_HERE'\",\n \"def make_anonymous_factorial():\\n return 'YOUR_EXPRESSION_HERE'\",\n \"def make_anonymous_factorial():\\n return 'YOUR_EXPRESSION_HERE'\",\n \"def numer(self, a):\\n return a\",\n \"def generateCodeWithoutIndices(self, codeGenerator):\\n return self.variable.generateCode(codeGenerator)\",\n \"def generate(self):\\n pass\",\n \"def n():\\n # For documentation purposes\",\n \"def generate(self):\\n start = self.nu_idx\\n stop = start + self.score\\n return self.orig_nu[start:stop]\",\n \"def fortran_functions(self) -> str:\\n fun_name = f'{self.f_prefix}_{self.name}_to_int_'\\n result = f'integer function {fun_name}(flags)\\\\n'\\n result += ' implicit none\\\\n'\\n result += '\\\\n'\\n result += f' class({self.f_prefix}_{self.name}), intent(in) :: flags\\\\n'\\n result += ' integer :: ret_val\\\\n'\\n result += '\\\\n'\\n result += ' ret_val = 0\\\\n'\\n for i, value in enumerate(self.values):\\n result += f\\\" if (flags%{value}) ret_val = ret_val + {1 << i}\\\\n\\\"\\n result += f' {fun_name} = ret_val\\\\n'\\n result += f'end function {fun_name}\\\\n'\\n return indent(result, 4*' ')\",\n \"def generate(self):\\n pass\",\n \"def generate(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66350216","0.6155325","0.6070667","0.60567296","0.6001382","0.5999806","0.5950534","0.5930682","0.58927596","0.5881666","0.5805855","0.57972014","0.5767194","0.5750545","0.5731919","0.5724899","0.57187545","0.56876415","0.5651061","0.564188","0.5631152","0.5618048","0.5610541","0.5593706","0.55687916","0.5566384","0.5553317","0.5544792","0.5536363","0.5524753","0.5491659","0.5484553","0.547359","0.54648966","0.54603946","0.5424518","0.54062986","0.539802","0.53633404","0.5356967","0.53446174","0.5333481","0.53321135","0.53303194","0.53244406","0.5320012","0.53111434","0.5310648","0.53087324","0.5304848","0.5293291","0.52908844","0.52899855","0.52870584","0.52800214","0.5279358","0.52662784","0.5258946","0.525734","0.52444535","0.52377933","0.52352643","0.5235128","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52328706","0.52134407","0.52112687","0.52112687","0.51981974","0.5197065","0.5188733","0.51804525","0.51785547","0.5168554","0.51629084","0.51569605","0.51539624","0.5153407","0.51477504","0.51477504","0.51477504","0.51477504","0.51461905","0.5143231","0.514067","0.51395833","0.5138481","0.51342964","0.51289666","0.51289666"],"string":"[\n \"0.66350216\",\n \"0.6155325\",\n \"0.6070667\",\n \"0.60567296\",\n \"0.6001382\",\n \"0.5999806\",\n \"0.5950534\",\n \"0.5930682\",\n \"0.58927596\",\n \"0.5881666\",\n \"0.5805855\",\n \"0.57972014\",\n \"0.5767194\",\n \"0.5750545\",\n \"0.5731919\",\n \"0.5724899\",\n \"0.57187545\",\n \"0.56876415\",\n \"0.5651061\",\n \"0.564188\",\n \"0.5631152\",\n \"0.5618048\",\n \"0.5610541\",\n \"0.5593706\",\n \"0.55687916\",\n \"0.5566384\",\n \"0.5553317\",\n \"0.5544792\",\n \"0.5536363\",\n \"0.5524753\",\n \"0.5491659\",\n \"0.5484553\",\n \"0.547359\",\n \"0.54648966\",\n \"0.54603946\",\n \"0.5424518\",\n \"0.54062986\",\n \"0.539802\",\n \"0.53633404\",\n \"0.5356967\",\n \"0.53446174\",\n \"0.5333481\",\n \"0.53321135\",\n \"0.53303194\",\n \"0.53244406\",\n \"0.5320012\",\n \"0.53111434\",\n \"0.5310648\",\n \"0.53087324\",\n \"0.5304848\",\n \"0.5293291\",\n \"0.52908844\",\n \"0.52899855\",\n \"0.52870584\",\n \"0.52800214\",\n \"0.5279358\",\n \"0.52662784\",\n \"0.5258946\",\n \"0.525734\",\n \"0.52444535\",\n \"0.52377933\",\n \"0.52352643\",\n \"0.5235128\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52328706\",\n \"0.52134407\",\n \"0.52112687\",\n \"0.52112687\",\n \"0.51981974\",\n \"0.5197065\",\n \"0.5188733\",\n \"0.51804525\",\n \"0.51785547\",\n \"0.5168554\",\n \"0.51629084\",\n \"0.51569605\",\n \"0.51539624\",\n \"0.5153407\",\n \"0.51477504\",\n \"0.51477504\",\n \"0.51477504\",\n \"0.51477504\",\n \"0.51461905\",\n \"0.5143231\",\n \"0.514067\",\n \"0.51395833\",\n \"0.5138481\",\n \"0.51342964\",\n \"0.51289666\",\n \"0.51289666\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":87199,"cells":{"query":{"kind":"string","value":"Return the generated function"},"document":{"kind":"string","value":"def function(self):\n return self.generator.module.Bouzidi_bounce_back"},"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 getFunction(self) -> ghidra.program.model.listing.Function:\n ...","def gen_function(self, function):\n if function.body:\n self.gen_function_def(function)","def func ( self ) :\n return self.__func","def func ( self ) :\n return self.__func","def __call__(self):\n return self.generate()","def RandomFunction(self):\r\n return self._random_fn","def __call__(fun_name):","def _func(self):\n return self._get_flint_func(self.domain)","def function(self):\n raise NotImplementedError","def _gen_closure(fnc,arg):\n return lambda s: fnc(arg)","def get_function(self):\n return subs(self.f.get_function(), self.sub_pre, self.sub_post)","def fn():","def get_gen_loop_fun(param_dict, fun_dict):\n def f(x_pl, hid_pl, count, f_state, eps_z, eps_x):\n return gen_loop(x_pl, hid_pl, count, f_state, eps_z, eps_x, param_dict, fun_dict)\n return f","def generate():","def make_transform_fn(self, ):\n return self._transform_fn","def createTransformFunc(self):\n raise NotImplementedError()","def get_transform_fn():","def generate(self, namespace: Optional[str], template: str, func: Callable, call_args: Dict) -> str:","def function(self):\n return self.generator.module.neumannz","def func():","def function(self):\n return self.generator.module.neumannx","def get_function(self):\n raise NotImplementedError()","def function(self):\n return self.generator.module.neumanny","def getFunction(self, name: unicode) -> ghidra.program.model.listing.Function:\n ...","def _create_function(self, expr):\n bb_entry = self.fn.append_basic_block('entry')\n builder = ll.IRBuilder(bb_entry)\n\n lj = LLVMJitCallbackPrinter(self.module, builder, self.fn,\n func_arg_map=self.param_dict)\n\n ret = self._convert_expr(lj, expr)\n\n if self.signature.ret_arg:\n output_fp_ptr = builder.bitcast(self.fn.args[self.signature.ret_arg],\n ll.PointerType(self.fp_type))\n for i, val in enumerate(ret):\n index = ll.Constant(ll.IntType(32), i)\n output_array_ptr = builder.gep(output_fp_ptr, [index])\n builder.store(val, output_array_ptr)\n builder.ret(ll.Constant(ll.IntType(32), 0)) # return success\n else:\n lj.builder.ret(self._wrap_return(lj, ret))\n\n strmod = str(self.module)\n return strmod","def _generate_fun(self, name, specstr, resname, specnames, docodeinserts=False):\n\n fdef = self._fn_template.format(\n name=name,\n start=self._format_user_code(self.opts['start']) if docodeinserts else '',\n spec=specstr,\n end=self._format_user_code(self.opts['end']) if docodeinserts else '',\n result=makeParList(range(len(specnames)), resname)\n )\n return '\\n'.join([s for s in fdef.split('\\n') if s]) + '\\n'","def generate(self):","def __call__(self):\n return self.fn()","def getFunction(self):\n return lambda x: self.slope * x + self.ordinate","def get_decorated_function(self):","def convert_function(self, access_modifier, return_type, func_name, params):\n\n # Run super func_name\n access_modifier, return_type, func_name, params = \\\n super().convert_function(access_modifier, return_type,\n func_name, params)\n\n # Make and return processed function definition\n return [self.make_function_definition(return_type, func_name, params)], []","def make_function(self):\n result = {}\n x0 = 0\n for i, x in enumerate(self.step_vals):\n vals_range = xrange(x0, x)\n for k in vals_range:\n result[k] = i\n x0 = x\n self.function = result","def function(self):\n return self.generator.module.neumann","def fn(self):\n return self._fn","def getCallable():","def view_function(self,v):\n return v","def function(self, name):\n return function_documentor(name)","def generate(self):\r\n raise NotImplementedError","def GenerateSpecialFunction(n):\n return eval('lambda a: %s' % GenerateSpecialExpression(n))","def createFunction(self, entryPoint: ghidra.program.model.address.Address, name: unicode) -> ghidra.program.model.listing.Function:\n ...","def f():","def f():","def get_now_func():\n return _now_func[0]","def cpp_function(self):","def _generate_and_save_function(self, filename, expression, parameters):\n\n # check for / create the save folder for this expression\n folder = self.config_folder + '/' + filename\n abr_control.utils.os_utils.makedirs(folder)\n\n if self.use_cython is True:\n # binaries saved by specifying tempdir parameter\n function = autowrap(expression, backend=\"cython\",\n args=parameters, tempdir=folder)\n function = sp.lambdify(parameters, expression, \"numpy\")\n\n return function","def get_real_function( this, fn):\n\t\treturn this._get_native_function(fn)","def generate(self):\n return self.gen.generate()","def code(self):\n if not self._code:\n filename = '<fluxtools function %s>' % self.tag\n self._code = compile(self.math, filename, mode='eval')\n return self._code","def for_function(self, func):\n return self.for_pysig(utils.pysignature(func))","def createFunctionTerm(self):\n return _libsbml.Transition_createFunctionTerm(self)","def _make_callable(func):\n try:\n return func.evaluator()\n except AttributeError:\n return func","def _create_function(self, expr):\n bb_entry = self.fn.append_basic_block('entry')\n builder = ll.IRBuilder(bb_entry)\n\n lj = LLVMJitPrinter(self.module, builder, self.fn,\n func_arg_map=self.param_dict)\n\n ret = self._convert_expr(lj, expr)\n lj.builder.ret(self._wrap_return(lj, ret))\n\n strmod = str(self.module)\n return strmod","def fortran_function(self) -> str:\n return ''.join([i.fortran_function() for i in self.instances])","def make_c_function_stubs(self):\n fn =\\\n\"\"\"{rettype} {fnname}({args}){{\n {rettype} ret;\n\n ret = {cast_and_deref}___madz_LANG_python_OUTPUT.{nodename}({argnames});\n\n return ret;\n}}\n\n\"\"\"\n fn_no_return =\\\n\"\"\"{rettype} {fnname}({args}){{\n ___madz_LANG_python_OUTPUT.{nodename}({argnames});\n return;\n}}\n\n\"\"\"\n res = \"\"\n c_gen = c_wrapgen.CGenerator([],\"\", self.description)\n for node in self.description.definitions():\n if isinstance(node.type.get_type(), pdl.TypeFunction):\n fragments = {\n \"maybe_parentheses\": \")\" if isinstance(node.type.return_type.get_type(),pdl.TypeStruct) else \"\",\n \"cast_and_deref\": self.make_c_cast_deref_string(c_gen, node.type.return_type),\n \"rettype\": c_gen.gen_type_string(\"\", node.type.return_type),\n \"fnname\": \"___madz_LANG_python_FN_\" + node.name,\n \"nodename\": node.name,\n \"args\": \",\".join(map(\n lambda a: c_gen.gen_type_string(a.name, a.type),\n node.type.args)),\n \"argnames\":\",\".join(map(\n lambda a: a.name,\n node.type.args))\n }\n res += (fn if not isinstance(node.type.return_type, pdl.TypeTypeNone) else fn_no_return).format(**fragments)\n return res","def get_function(self):\n return SSAFunction(self.get_graph())","def create_function(self, function):\n if function.body:\n self.create_function_internal(function)\n else:\n self.create_function_external(function)","def generate(self):\n pass","def f(self):\n return self._f","def __def_function__():\n pass","def new_generator(self):\n return self.generator_function(*self.args, **self.kwargs)","def lin_o_func(self):\n return self.hx","def __call__(self, *args, **kwargs):\n return function(args, addtional_info)","def createFunctionDefinition(self):\n return _libsbml.Model_createFunctionDefinition(self)","def getFunction(self, key: long) -> ghidra.program.model.listing.Function:\n ...","def make_score_fn(self):\n return self._score_fn","def retfun():\r\n return fn(*args, **kwargs)","def __get_function(self):\n return random.choice(self.FUNCTIONS)","def fortran_function(self) -> str:\n if self.f_override is not None:\n return indent(\n self.f_override.replace('$CLASSNAME$', self.class_name).replace(\n \"$C_PREFIX$\", self.c_prefix).replace(\n \"$F_PREFIX$\", self.f_prefix),\n 4*' ')\n\n result = ''\n\n # declaration\n func_name = '{}_{}_{}'.format(\n self.f_prefix, self.class_name, self.name)\n in_parameters = self._f_in_parameters()\n return_type, out_parameters = self._f_out_parameters()\n if self.may_throw:\n out_parameters.append(('integer, optional', 'err_code'))\n out_parameters.append(('character(:), allocatable, optional',\n 'err_msg'))\n\n all_parameters = in_parameters + out_parameters\n arg_list = ', &\\n'.join([par_name for _, par_name in all_parameters])\n arg_ilist = indent(arg_list, 8*' ')\n if return_type != '':\n result += 'function {}( &\\n{})\\n'.format(func_name, arg_ilist)\n else:\n result += 'subroutine {}( &\\n{})\\n'.format(func_name, arg_ilist)\n\n # parameter declarations\n result += ' implicit none\\n'\n for par_type, par_name in in_parameters:\n result += ' {}, intent(in) :: {}\\n'.format(\n par_type, par_name)\n for par_type, par_name in out_parameters:\n result += ' {}, intent(out) :: {}\\n'.format(par_type, par_name)\n if return_type != '':\n result += ' {} :: {}\\n'.format(return_type, func_name)\n result += '\\n'\n\n # variable declarations\n c_return_type, fi_out_parameters = self._fi_out_parameters()\n if c_return_type:\n result += ' {} :: ret_val\\n'.format(c_return_type)\n for par_type, par_name in fi_out_parameters:\n result += ' {} :: {}\\n'.format(par_type, par_name)\n for par_type, par_name in self.ret_type.f_aux_variables():\n result += ' {} :: {}\\n'.format(par_type, par_name)\n if self.may_throw:\n result += ' integer (c_int) :: err_code_v\\n'\n result += ' type (c_ptr) :: err_msg_v\\n'\n result += ' integer (c_size_t) :: err_msg_len_v\\n'\n result += ' character (c_char), dimension(:), pointer :: err_msg_f\\n'\n result += ' character(:), allocatable :: err_msg_p\\n'\n result += ' integer (c_size_t) :: err_msg_i\\n'\n if c_return_type or fi_out_parameters or self.may_throw:\n result += '\\n'\n\n # convert input\n args = [param.f_chain_arg() for param in self.params]\n args += [par_name for _, par_name in fi_out_parameters]\n if self.may_throw:\n args += ['err_code_v', 'err_msg_v', 'err_msg_len_v']\n arg_str = ', &\\n'.join([8*' ' + arg for arg in args])\n\n # call C function\n fc_func_name = '{}_{}_{}_'.format(\n self.c_prefix, self.class_name, self.name)\n chain_call = self.fc_chain_call(\n ns_prefix=self.c_prefix, class_name=self.class_name,\n fc_func_name=fc_func_name, fc_args=arg_str)\n result_name = ''\n if return_type != '':\n result_name = func_name\n elif out_parameters:\n result_name = out_parameters[0][1]\n result += self.ret_type.f_call_c('ret_val', chain_call)\n\n # handle errors if necessary\n if self.may_throw:\n # Note: I tried to factor this out into a function, but Fortran\n # makes that near-impossible. Since we're generating anyway, it's\n # not really duplication, so leave it as is.\n result += indent(dedent(f\"\"\"\\\n if (err_code_v .ne. 0) then\n if (present(err_code)) then\n err_code = err_code_v\n if (present(err_msg)) then\n call c_f_pointer(err_msg_v, err_msg_f, (/err_msg_len_v/))\n allocate (character(err_msg_len_v) :: err_msg)\n do err_msg_i = 1, err_msg_len_v\n err_msg(err_msg_i:err_msg_i) = err_msg_f(err_msg_i)\n end do\n end if\n {dedent(\n self.ret_type.f_return_dummy_result(result_name))}\n return\n else\n call c_f_pointer(err_msg_v, err_msg_f, (/err_msg_len_v/))\n allocate (character(err_msg_len_v) :: err_msg_p)\n do err_msg_i = 1, err_msg_len_v\n err_msg_p(err_msg_i:err_msg_i) = err_msg_f(err_msg_i)\n end do\n print *, err_msg_p\n stop\n end if\n else\n if (present(err_code)) then\n err_code = 0\n end if\n end if\n\n \"\"\"), 4*' ')\n\n # convert and return result\n result += self.ret_type.f_return_result(result_name, 'ret_val')\n\n # end\n if return_type != '':\n result += 'end function {}\\n\\n'.format(func_name)\n else:\n result += 'end subroutine {}\\n\\n'.format(func_name)\n return indent(result, 4*' ')","def function_uuid():\r\n yield uuid.uuid4()","def compile_function(self, function, arguments):","def build_pfunc(cls, representation):\n if ut.is_str(representation):\n try:\n func = eval(representation)\n except:\n bf = 'cls.build_pfunc('\n af = ')'\n st = ut.parse_enclose_with_counter(representation , before = bf, after = af)\n func = eval(st)\n \n elif ut.is_dico(representation):\n name_func = representation['name_func']\n func = eval(name_func)(**representation)\n \n else:\n raise SystemError(\"build_custom_func can build a function from an \"\n \"object of tye {0}\".format(cls.__class__))\n \n return func","def relay_to_tir(name, func):\n return GenerateTIR(name).generate_tir(func)","def function(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"function\")","def function(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"function\")","def function(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"function\")","def function_maker(self, i, o, m, *args, **kwargs):\r\n assert m is self\r\n return _Maker(i, o, self.optimizer, self, *args, **kwargs)","def build_model_fn(self):","def func(f):\n return func_custom(f.func_name)(f)","def make_main_function(self):\n\t\tself.main = self.tokens.get_joined()\n\t\tfor func in self.func_dict:\n\t\t\tself.main = self.main.replace(self.func_dict[func], func)","def GenerateNormalFunction(n):\n return eval('lambda a: %s' % GenerateNormalExpression(n))","def function_generator(decorated_function):\n\n def extended_func(*args, **kwargs):\n \"\"\"\n The result function, that wraps decorated function.\n \"\"\"\n return number * decorated_function(*args, **kwargs)\n\n return extended_func","def get_function(self):\n return self.element.get_basis_functions()[self.n]","def _wrap_in_generator(func, source, namer, overload):\n\n nonlocals = []\n\n for var in six.get_function_code(func).co_freevars:\n # We must generate dummy vars so the generated function has the same closure\n # as the original function.\n free_template = 'var = None'\n nonlocal_node = templates.replace(free_template, var=var)\n nonlocals.extend(nonlocal_node)\n\n gen_fun_name = namer.new_symbol('gen_fun', set())\n template = \"\"\"\n def gen_fun(overload):\n nonlocals\n\n program\n\n return f_name\n \"\"\"\n\n ret = templates.replace(\n template,\n gen_fun=gen_fun_name,\n nonlocals=nonlocals,\n overload=overload.symbol_name,\n program=source,\n f_name=func.__name__)\n\n converted_module, _ = parsing.ast_to_object(ret)\n outer_func = getattr(converted_module, gen_fun_name)\n return outer_func(overload.module)","def firstFunction(self):","def get_function(self):\n return Gumtree.gumtree.getFunction()","def generate(self):\n pass","def generate(self):\n pass","def generate(self):\n pass","def __compile__(self) -> types.FunctionType:\n code = {}\n exec(compile(self.__build_method__(), '<string>', 'exec'), code)\n return code[\"solve\"]","def fn(self):\n return \"Hello\"","def get_a_func(self, is_training=False, reuse=False):\n return functools.partial(self.a_func,\n num_actions=self._action_size,\n scope='a_func',\n reuse=reuse,\n is_training=is_training)","def _random_function(self, random_state):\n return random_state.rand","def __call__(self, function: FuncSpeechArg):\n self._add_attr(function)\n return function","def _gen_code(self):\r\n #TODO: maybe generate one C function only to save compile time? Also easier to take that as a basis and hand craft other covariances??\r\n\r\n #generate c functions from sympy objects \r\n argument_sequence = self._sp_x+self._sp_z+self._sp_theta\r\n code_list = [('k',self._sp_k)]\r\n # gradients with respect to covariance input\r\n code_list += [('dk_d%s'%x.name,dx) for x,dx in zip(self._sp_x,self._sp_dk_dx)]\r\n # gradient with respect to parameters\r\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta,self._sp_dk_dtheta)]\r\n # gradient with respect to multiple output parameters\r\n if self.output_dim > 1:\r\n argument_sequence += self._sp_theta_i + self._sp_theta_j\r\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta_i,self._sp_dk_dtheta_i)]\r\n (foo_c,self._function_code), (foo_h,self._function_header) = \\\r\n codegen(code_list, \"C\",'foobar',argument_sequence=argument_sequence)\r\n #put the header file where we can find it\r\n f = file(os.path.join(tempfile.gettempdir(),'foobar.h'),'w')\r\n f.write(self._function_header)\r\n f.close()\r\n\r\n # Substitute any known derivatives which sympy doesn't compute\r\n self._function_code = re.sub('DiracDelta\\(.+?,.+?\\)','0.0',self._function_code)\r\n\r\n\r\n ############################################################\r\n # This is the basic argument construction for the C code. #\r\n ############################################################\r\n \r\n arg_list = ([\"X2(i, %s)\"%x.name[2:] for x in self._sp_x]\r\n + [\"Z2(j, %s)\"%z.name[2:] for z in self._sp_z])\r\n\r\n # for multiple outputs need to also provide these arguments reversed.\r\n if self.output_dim>1:\r\n reverse_arg_list = list(arg_list)\r\n reverse_arg_list.reverse()\r\n\r\n # Add in any 'shared' parameters to the list.\r\n param_arg_list = [shared_params.name for shared_params in self._sp_theta]\r\n arg_list += param_arg_list\r\n\r\n precompute_list=[]\r\n if self.output_dim > 1:\r\n reverse_arg_list+=list(param_arg_list)\r\n split_param_arg_list = [\"%s1(%s)\"%(theta.name[:-2].upper(),index) for index in ['ii', 'jj'] for theta in self._sp_theta_i]\r\n split_param_reverse_arg_list = [\"%s1(%s)\"%(theta.name[:-2].upper(),index) for index in ['jj', 'ii'] for theta in self._sp_theta_i]\r\n arg_list += split_param_arg_list\r\n reverse_arg_list += split_param_reverse_arg_list\r\n # Extract the right output indices from the inputs.\r\n c_define_output_indices = [' '*16 + \"int %s=(int)%s(%s, %i);\"%(index, var, index2, self.input_dim-1) for index, var, index2 in zip(['ii', 'jj'], ['X2', 'Z2'], ['i', 'j'])]\r\n precompute_list += c_define_output_indices\r\n reverse_arg_string = \", \".join(reverse_arg_list)\r\n arg_string = \", \".join(arg_list)\r\n precompute_string = \"\\n\".join(precompute_list)\r\n\r\n # Code to compute argments string needed when only X is provided.\r\n X_arg_string = re.sub('Z','X',arg_string)\r\n # Code to compute argument string when only diagonal is required.\r\n diag_arg_string = re.sub('int jj','//int jj',X_arg_string)\r\n diag_arg_string = re.sub('j','i',diag_arg_string)\r\n if precompute_string == '':\r\n # if it's not multioutput, the precompute strings are set to zero\r\n diag_precompute_string = ''\r\n diag_precompute_replace = ''\r\n else:\r\n # for multioutput we need to extract the index of the output form the input.\r\n diag_precompute_string = precompute_list[0]\r\n diag_precompute_replace = precompute_list[1]\r\n \r\n\r\n # Here's the code to do the looping for K\r\n self._K_code =\\\r\n \"\"\"\r\n // _K_code\r\n // Code for computing the covariance function.\r\n int i;\r\n int j;\r\n int N = target_array->dimensions[0];\r\n int num_inducing = target_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N;i++){\r\n for (j=0;j<num_inducing;j++){\r\n%s\r\n //target[i*num_inducing+j] = \r\n TARGET2(i, j) += k(%s);\r\n }\r\n }\r\n %s\r\n \"\"\"%(precompute_string,arg_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n\r\n self._K_code_X = \"\"\"\r\n // _K_code_X\r\n // Code for computing the covariance function.\r\n int i;\r\n int j;\r\n int N = target_array->dimensions[0];\r\n int num_inducing = target_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N;i++){\r\n %s // int ii=(int)X2(i, 1);\r\n TARGET2(i, i) += k(%s);\r\n for (j=0;j<i;j++){\r\n %s //int jj=(int)X2(j, 1);\r\n double kval = k(%s); //double kval = k(X2(i, 0), shared_lengthscale, LENGTHSCALE1(ii), SCALE1(ii));\r\n TARGET2(i, j) += kval;\r\n TARGET2(j, i) += kval;\r\n }\r\n }\r\n /*%s*/\r\n \"\"\"%(diag_precompute_string, diag_arg_string, re.sub('Z2', 'X2', diag_precompute_replace), X_arg_string,str(self._sp_k)) #adding a string representation forces recompile when needed\r\n\r\n # Code to do the looping for Kdiag\r\n self._Kdiag_code =\\\r\n \"\"\"\r\n // _Kdiag_code\r\n // Code for computing diagonal of covariance function.\r\n int i;\r\n int N = target_array->dimensions[0];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for\r\n for (i=0;i<N;i++){\r\n %s\r\n //target[i] =\r\n TARGET1(i)=k(%s);\r\n }\r\n %s\r\n \"\"\"%(diag_precompute_string,diag_arg_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n\r\n # Code to compute gradients\r\n grad_func_list = []\r\n if self.output_dim>1:\r\n grad_func_list += c_define_output_indices\r\n grad_func_list += [' '*16 + 'TARGET1(%i+ii) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, arg_string) for i, theta in enumerate(self._sp_theta_i)]\r\n grad_func_list += [' '*16 + 'TARGET1(%i+jj) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, reverse_arg_string) for i, theta in enumerate(self._sp_theta_i)]\r\n grad_func_list += ([' '*16 + 'TARGET1(%i) += PARTIAL2(i, j)*dk_d%s(%s);'%(i,theta.name,arg_string) for i,theta in enumerate(self._sp_theta)])\r\n grad_func_string = '\\n'.join(grad_func_list) \r\n\r\n self._dK_dtheta_code =\\\r\n \"\"\"\r\n // _dK_dtheta_code\r\n // Code for computing gradient of covariance with respect to parameters.\r\n int i;\r\n int j;\r\n int N = partial_array->dimensions[0];\r\n int num_inducing = partial_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N;i++){\r\n for (j=0;j<num_inducing;j++){\r\n%s\r\n }\r\n }\r\n %s\r\n \"\"\"%(grad_func_string,\"/*\"+str(self._sp_k)+\"*/\") # adding a string representation forces recompile when needed\r\n\r\n\r\n # Code to compute gradients for Kdiag TODO: needs clean up\r\n diag_grad_func_string = re.sub('Z','X',grad_func_string,count=0)\r\n diag_grad_func_string = re.sub('int jj','//int jj',diag_grad_func_string)\r\n diag_grad_func_string = re.sub('j','i',diag_grad_func_string)\r\n diag_grad_func_string = re.sub('PARTIAL2\\(i, i\\)','PARTIAL1(i)',diag_grad_func_string)\r\n self._dKdiag_dtheta_code =\\\r\n \"\"\"\r\n // _dKdiag_dtheta_code\r\n // Code for computing gradient of diagonal with respect to parameters.\r\n int i;\r\n int N = partial_array->dimensions[0];\r\n int input_dim = X_array->dimensions[1];\r\n for (i=0;i<N;i++){\r\n %s\r\n }\r\n %s\r\n \"\"\"%(diag_grad_func_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n\r\n # Code for gradients wrt X, TODO: may need to deal with special case where one input is actually an output.\r\n gradX_func_list = []\r\n if self.output_dim>1:\r\n gradX_func_list += c_define_output_indices\r\n gradX_func_list += [\"TARGET2(i, %i) += PARTIAL2(i, j)*dk_dx_%i(%s);\"%(q,q,arg_string) for q in range(self._real_input_dim)]\r\n gradX_func_string = \"\\n\".join(gradX_func_list)\r\n\r\n self._dK_dX_code = \\\r\n \"\"\"\r\n // _dK_dX_code\r\n // Code for computing gradient of covariance with respect to inputs.\r\n int i;\r\n int j;\r\n int N = partial_array->dimensions[0];\r\n int num_inducing = partial_array->dimensions[1];\r\n int input_dim = X_array->dimensions[1];\r\n //#pragma omp parallel for private(j)\r\n for (i=0;i<N; i++){\r\n for (j=0; j<num_inducing; j++){\r\n %s\r\n }\r\n }\r\n %s\r\n \"\"\"%(gradX_func_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a string representation forces recompile when needed\r\n \r\n\r\n diag_gradX_func_string = re.sub('Z','X',gradX_func_string,count=0)\r\n diag_gradX_func_string = re.sub('int jj','//int jj',diag_gradX_func_string)\r\n diag_gradX_func_string = re.sub('j','i',diag_gradX_func_string)\r\n diag_gradX_func_string = re.sub('PARTIAL2\\(i, i\\)','2*PARTIAL1(i)',diag_gradX_func_string)\r\n\r\n # Code for gradients of Kdiag wrt X\r\n self._dKdiag_dX_code= \\\r\n \"\"\"\r\n // _dKdiag_dX_code\r\n // Code for computing gradient of diagonal with respect to inputs.\r\n int N = partial_array->dimensions[0];\r\n int input_dim = X_array->dimensions[1];\r\n for (int i=0;i<N; i++){\r\n %s\r\n }\r\n %s\r\n \"\"\"%(diag_gradX_func_string,\"/*\"+str(self._sp_k)+\"*/\") #adding a\r\n # string representation forces recompile when needed Get rid\r\n # of Zs in argument for diagonal. TODO: Why wasn't\r\n # diag_func_string called here? Need to check that.\r\n #self._dKdiag_dX_code = self._dKdiag_dX_code.replace('Z[j', 'X[i')\r\n\r\n # Code to use when only X is provided. \r\n self._dK_dtheta_code_X = self._dK_dtheta_code.replace('Z[', 'X[')\r\n self._dK_dX_code_X = self._dK_dX_code.replace('Z[', 'X[').replace('+= PARTIAL2(', '+= 2*PARTIAL2(') \r\n self._dK_dtheta_code_X = self._dK_dtheta_code_X.replace('Z2(', 'X2(')\r\n self._dK_dX_code_X = self._dK_dX_code_X.replace('Z2(', 'X2(')\r\n\r\n\r\n #TODO: insert multiple functions here via string manipulation\r\n #TODO: similar functions for psi_stats\r","def a_function_of_mine():\n return 'result'","def python_function(self):\n return self._python_function # pylint: disable=protected-access","def function(self):\n return self.devicefuncs[self._funcname]","def func(cls):\n return cls.get_wrapper()(cls.callable)","def special_def(self, form):\n if not len(form) >= 3:\n raise SyntaxError(\"Not enough forms in %s\" % form)\n if not isinstance(form[1], Form):\n raise SyntaxError(\"Expected a list of [funname args...]\")\n\n doc, code = self._getDocAndCode(form[2:])\n #print \"GOT\", code\n #code.nodes[-1] = ast.Return(code.nodes[-1])\n args = [x.name for x in form[1][1:]]\n \n magicode = self._getMagicCodeForArgs(args)\n \n return ast.Function(None, form[1][0].name, args, [], magicode, doc, code)","def gen_vee_func(self):\n dual_func = self.dual_func\n omt_func = self.omt_func\n @numba.njit\n def vee(aval, bval):\n return dual_func(omt_func(dual_func(aval), dual_func(bval)))\n return vee","def function(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"function\")"],"string":"[\n \"def getFunction(self) -> ghidra.program.model.listing.Function:\\n ...\",\n \"def gen_function(self, function):\\n if function.body:\\n self.gen_function_def(function)\",\n \"def func ( self ) :\\n return self.__func\",\n \"def func ( self ) :\\n return self.__func\",\n \"def __call__(self):\\n return self.generate()\",\n \"def RandomFunction(self):\\r\\n return self._random_fn\",\n \"def __call__(fun_name):\",\n \"def _func(self):\\n return self._get_flint_func(self.domain)\",\n \"def function(self):\\n raise NotImplementedError\",\n \"def _gen_closure(fnc,arg):\\n return lambda s: fnc(arg)\",\n \"def get_function(self):\\n return subs(self.f.get_function(), self.sub_pre, self.sub_post)\",\n \"def fn():\",\n \"def get_gen_loop_fun(param_dict, fun_dict):\\n def f(x_pl, hid_pl, count, f_state, eps_z, eps_x):\\n return gen_loop(x_pl, hid_pl, count, f_state, eps_z, eps_x, param_dict, fun_dict)\\n return f\",\n \"def generate():\",\n \"def make_transform_fn(self, ):\\n return self._transform_fn\",\n \"def createTransformFunc(self):\\n raise NotImplementedError()\",\n \"def get_transform_fn():\",\n \"def generate(self, namespace: Optional[str], template: str, func: Callable, call_args: Dict) -> str:\",\n \"def function(self):\\n return self.generator.module.neumannz\",\n \"def func():\",\n \"def function(self):\\n return self.generator.module.neumannx\",\n \"def get_function(self):\\n raise NotImplementedError()\",\n \"def function(self):\\n return self.generator.module.neumanny\",\n \"def getFunction(self, name: unicode) -> ghidra.program.model.listing.Function:\\n ...\",\n \"def _create_function(self, expr):\\n bb_entry = self.fn.append_basic_block('entry')\\n builder = ll.IRBuilder(bb_entry)\\n\\n lj = LLVMJitCallbackPrinter(self.module, builder, self.fn,\\n func_arg_map=self.param_dict)\\n\\n ret = self._convert_expr(lj, expr)\\n\\n if self.signature.ret_arg:\\n output_fp_ptr = builder.bitcast(self.fn.args[self.signature.ret_arg],\\n ll.PointerType(self.fp_type))\\n for i, val in enumerate(ret):\\n index = ll.Constant(ll.IntType(32), i)\\n output_array_ptr = builder.gep(output_fp_ptr, [index])\\n builder.store(val, output_array_ptr)\\n builder.ret(ll.Constant(ll.IntType(32), 0)) # return success\\n else:\\n lj.builder.ret(self._wrap_return(lj, ret))\\n\\n strmod = str(self.module)\\n return strmod\",\n \"def _generate_fun(self, name, specstr, resname, specnames, docodeinserts=False):\\n\\n fdef = self._fn_template.format(\\n name=name,\\n start=self._format_user_code(self.opts['start']) if docodeinserts else '',\\n spec=specstr,\\n end=self._format_user_code(self.opts['end']) if docodeinserts else '',\\n result=makeParList(range(len(specnames)), resname)\\n )\\n return '\\\\n'.join([s for s in fdef.split('\\\\n') if s]) + '\\\\n'\",\n \"def generate(self):\",\n \"def __call__(self):\\n return self.fn()\",\n \"def getFunction(self):\\n return lambda x: self.slope * x + self.ordinate\",\n \"def get_decorated_function(self):\",\n \"def convert_function(self, access_modifier, return_type, func_name, params):\\n\\n # Run super func_name\\n access_modifier, return_type, func_name, params = \\\\\\n super().convert_function(access_modifier, return_type,\\n func_name, params)\\n\\n # Make and return processed function definition\\n return [self.make_function_definition(return_type, func_name, params)], []\",\n \"def make_function(self):\\n result = {}\\n x0 = 0\\n for i, x in enumerate(self.step_vals):\\n vals_range = xrange(x0, x)\\n for k in vals_range:\\n result[k] = i\\n x0 = x\\n self.function = result\",\n \"def function(self):\\n return self.generator.module.neumann\",\n \"def fn(self):\\n return self._fn\",\n \"def getCallable():\",\n \"def view_function(self,v):\\n return v\",\n \"def function(self, name):\\n return function_documentor(name)\",\n \"def generate(self):\\r\\n raise NotImplementedError\",\n \"def GenerateSpecialFunction(n):\\n return eval('lambda a: %s' % GenerateSpecialExpression(n))\",\n \"def createFunction(self, entryPoint: ghidra.program.model.address.Address, name: unicode) -> ghidra.program.model.listing.Function:\\n ...\",\n \"def f():\",\n \"def f():\",\n \"def get_now_func():\\n return _now_func[0]\",\n \"def cpp_function(self):\",\n \"def _generate_and_save_function(self, filename, expression, parameters):\\n\\n # check for / create the save folder for this expression\\n folder = self.config_folder + '/' + filename\\n abr_control.utils.os_utils.makedirs(folder)\\n\\n if self.use_cython is True:\\n # binaries saved by specifying tempdir parameter\\n function = autowrap(expression, backend=\\\"cython\\\",\\n args=parameters, tempdir=folder)\\n function = sp.lambdify(parameters, expression, \\\"numpy\\\")\\n\\n return function\",\n \"def get_real_function( this, fn):\\n\\t\\treturn this._get_native_function(fn)\",\n \"def generate(self):\\n return self.gen.generate()\",\n \"def code(self):\\n if not self._code:\\n filename = '<fluxtools function %s>' % self.tag\\n self._code = compile(self.math, filename, mode='eval')\\n return self._code\",\n \"def for_function(self, func):\\n return self.for_pysig(utils.pysignature(func))\",\n \"def createFunctionTerm(self):\\n return _libsbml.Transition_createFunctionTerm(self)\",\n \"def _make_callable(func):\\n try:\\n return func.evaluator()\\n except AttributeError:\\n return func\",\n \"def _create_function(self, expr):\\n bb_entry = self.fn.append_basic_block('entry')\\n builder = ll.IRBuilder(bb_entry)\\n\\n lj = LLVMJitPrinter(self.module, builder, self.fn,\\n func_arg_map=self.param_dict)\\n\\n ret = self._convert_expr(lj, expr)\\n lj.builder.ret(self._wrap_return(lj, ret))\\n\\n strmod = str(self.module)\\n return strmod\",\n \"def fortran_function(self) -> str:\\n return ''.join([i.fortran_function() for i in self.instances])\",\n \"def make_c_function_stubs(self):\\n fn =\\\\\\n\\\"\\\"\\\"{rettype} {fnname}({args}){{\\n {rettype} ret;\\n\\n ret = {cast_and_deref}___madz_LANG_python_OUTPUT.{nodename}({argnames});\\n\\n return ret;\\n}}\\n\\n\\\"\\\"\\\"\\n fn_no_return =\\\\\\n\\\"\\\"\\\"{rettype} {fnname}({args}){{\\n ___madz_LANG_python_OUTPUT.{nodename}({argnames});\\n return;\\n}}\\n\\n\\\"\\\"\\\"\\n res = \\\"\\\"\\n c_gen = c_wrapgen.CGenerator([],\\\"\\\", self.description)\\n for node in self.description.definitions():\\n if isinstance(node.type.get_type(), pdl.TypeFunction):\\n fragments = {\\n \\\"maybe_parentheses\\\": \\\")\\\" if isinstance(node.type.return_type.get_type(),pdl.TypeStruct) else \\\"\\\",\\n \\\"cast_and_deref\\\": self.make_c_cast_deref_string(c_gen, node.type.return_type),\\n \\\"rettype\\\": c_gen.gen_type_string(\\\"\\\", node.type.return_type),\\n \\\"fnname\\\": \\\"___madz_LANG_python_FN_\\\" + node.name,\\n \\\"nodename\\\": node.name,\\n \\\"args\\\": \\\",\\\".join(map(\\n lambda a: c_gen.gen_type_string(a.name, a.type),\\n node.type.args)),\\n \\\"argnames\\\":\\\",\\\".join(map(\\n lambda a: a.name,\\n node.type.args))\\n }\\n res += (fn if not isinstance(node.type.return_type, pdl.TypeTypeNone) else fn_no_return).format(**fragments)\\n return res\",\n \"def get_function(self):\\n return SSAFunction(self.get_graph())\",\n \"def create_function(self, function):\\n if function.body:\\n self.create_function_internal(function)\\n else:\\n self.create_function_external(function)\",\n \"def generate(self):\\n pass\",\n \"def f(self):\\n return self._f\",\n \"def __def_function__():\\n pass\",\n \"def new_generator(self):\\n return self.generator_function(*self.args, **self.kwargs)\",\n \"def lin_o_func(self):\\n return self.hx\",\n \"def __call__(self, *args, **kwargs):\\n return function(args, addtional_info)\",\n \"def createFunctionDefinition(self):\\n return _libsbml.Model_createFunctionDefinition(self)\",\n \"def getFunction(self, key: long) -> ghidra.program.model.listing.Function:\\n ...\",\n \"def make_score_fn(self):\\n return self._score_fn\",\n \"def retfun():\\r\\n return fn(*args, **kwargs)\",\n \"def __get_function(self):\\n return random.choice(self.FUNCTIONS)\",\n \"def fortran_function(self) -> str:\\n if self.f_override is not None:\\n return indent(\\n self.f_override.replace('$CLASSNAME$', self.class_name).replace(\\n \\\"$C_PREFIX$\\\", self.c_prefix).replace(\\n \\\"$F_PREFIX$\\\", self.f_prefix),\\n 4*' ')\\n\\n result = ''\\n\\n # declaration\\n func_name = '{}_{}_{}'.format(\\n self.f_prefix, self.class_name, self.name)\\n in_parameters = self._f_in_parameters()\\n return_type, out_parameters = self._f_out_parameters()\\n if self.may_throw:\\n out_parameters.append(('integer, optional', 'err_code'))\\n out_parameters.append(('character(:), allocatable, optional',\\n 'err_msg'))\\n\\n all_parameters = in_parameters + out_parameters\\n arg_list = ', &\\\\n'.join([par_name for _, par_name in all_parameters])\\n arg_ilist = indent(arg_list, 8*' ')\\n if return_type != '':\\n result += 'function {}( &\\\\n{})\\\\n'.format(func_name, arg_ilist)\\n else:\\n result += 'subroutine {}( &\\\\n{})\\\\n'.format(func_name, arg_ilist)\\n\\n # parameter declarations\\n result += ' implicit none\\\\n'\\n for par_type, par_name in in_parameters:\\n result += ' {}, intent(in) :: {}\\\\n'.format(\\n par_type, par_name)\\n for par_type, par_name in out_parameters:\\n result += ' {}, intent(out) :: {}\\\\n'.format(par_type, par_name)\\n if return_type != '':\\n result += ' {} :: {}\\\\n'.format(return_type, func_name)\\n result += '\\\\n'\\n\\n # variable declarations\\n c_return_type, fi_out_parameters = self._fi_out_parameters()\\n if c_return_type:\\n result += ' {} :: ret_val\\\\n'.format(c_return_type)\\n for par_type, par_name in fi_out_parameters:\\n result += ' {} :: {}\\\\n'.format(par_type, par_name)\\n for par_type, par_name in self.ret_type.f_aux_variables():\\n result += ' {} :: {}\\\\n'.format(par_type, par_name)\\n if self.may_throw:\\n result += ' integer (c_int) :: err_code_v\\\\n'\\n result += ' type (c_ptr) :: err_msg_v\\\\n'\\n result += ' integer (c_size_t) :: err_msg_len_v\\\\n'\\n result += ' character (c_char), dimension(:), pointer :: err_msg_f\\\\n'\\n result += ' character(:), allocatable :: err_msg_p\\\\n'\\n result += ' integer (c_size_t) :: err_msg_i\\\\n'\\n if c_return_type or fi_out_parameters or self.may_throw:\\n result += '\\\\n'\\n\\n # convert input\\n args = [param.f_chain_arg() for param in self.params]\\n args += [par_name for _, par_name in fi_out_parameters]\\n if self.may_throw:\\n args += ['err_code_v', 'err_msg_v', 'err_msg_len_v']\\n arg_str = ', &\\\\n'.join([8*' ' + arg for arg in args])\\n\\n # call C function\\n fc_func_name = '{}_{}_{}_'.format(\\n self.c_prefix, self.class_name, self.name)\\n chain_call = self.fc_chain_call(\\n ns_prefix=self.c_prefix, class_name=self.class_name,\\n fc_func_name=fc_func_name, fc_args=arg_str)\\n result_name = ''\\n if return_type != '':\\n result_name = func_name\\n elif out_parameters:\\n result_name = out_parameters[0][1]\\n result += self.ret_type.f_call_c('ret_val', chain_call)\\n\\n # handle errors if necessary\\n if self.may_throw:\\n # Note: I tried to factor this out into a function, but Fortran\\n # makes that near-impossible. Since we're generating anyway, it's\\n # not really duplication, so leave it as is.\\n result += indent(dedent(f\\\"\\\"\\\"\\\\\\n if (err_code_v .ne. 0) then\\n if (present(err_code)) then\\n err_code = err_code_v\\n if (present(err_msg)) then\\n call c_f_pointer(err_msg_v, err_msg_f, (/err_msg_len_v/))\\n allocate (character(err_msg_len_v) :: err_msg)\\n do err_msg_i = 1, err_msg_len_v\\n err_msg(err_msg_i:err_msg_i) = err_msg_f(err_msg_i)\\n end do\\n end if\\n {dedent(\\n self.ret_type.f_return_dummy_result(result_name))}\\n return\\n else\\n call c_f_pointer(err_msg_v, err_msg_f, (/err_msg_len_v/))\\n allocate (character(err_msg_len_v) :: err_msg_p)\\n do err_msg_i = 1, err_msg_len_v\\n err_msg_p(err_msg_i:err_msg_i) = err_msg_f(err_msg_i)\\n end do\\n print *, err_msg_p\\n stop\\n end if\\n else\\n if (present(err_code)) then\\n err_code = 0\\n end if\\n end if\\n\\n \\\"\\\"\\\"), 4*' ')\\n\\n # convert and return result\\n result += self.ret_type.f_return_result(result_name, 'ret_val')\\n\\n # end\\n if return_type != '':\\n result += 'end function {}\\\\n\\\\n'.format(func_name)\\n else:\\n result += 'end subroutine {}\\\\n\\\\n'.format(func_name)\\n return indent(result, 4*' ')\",\n \"def function_uuid():\\r\\n yield uuid.uuid4()\",\n \"def compile_function(self, function, arguments):\",\n \"def build_pfunc(cls, representation):\\n if ut.is_str(representation):\\n try:\\n func = eval(representation)\\n except:\\n bf = 'cls.build_pfunc('\\n af = ')'\\n st = ut.parse_enclose_with_counter(representation , before = bf, after = af)\\n func = eval(st)\\n \\n elif ut.is_dico(representation):\\n name_func = representation['name_func']\\n func = eval(name_func)(**representation)\\n \\n else:\\n raise SystemError(\\\"build_custom_func can build a function from an \\\"\\n \\\"object of tye {0}\\\".format(cls.__class__))\\n \\n return func\",\n \"def relay_to_tir(name, func):\\n return GenerateTIR(name).generate_tir(func)\",\n \"def function(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"function\\\")\",\n \"def function(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"function\\\")\",\n \"def function(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"function\\\")\",\n \"def function_maker(self, i, o, m, *args, **kwargs):\\r\\n assert m is self\\r\\n return _Maker(i, o, self.optimizer, self, *args, **kwargs)\",\n \"def build_model_fn(self):\",\n \"def func(f):\\n return func_custom(f.func_name)(f)\",\n \"def make_main_function(self):\\n\\t\\tself.main = self.tokens.get_joined()\\n\\t\\tfor func in self.func_dict:\\n\\t\\t\\tself.main = self.main.replace(self.func_dict[func], func)\",\n \"def GenerateNormalFunction(n):\\n return eval('lambda a: %s' % GenerateNormalExpression(n))\",\n \"def function_generator(decorated_function):\\n\\n def extended_func(*args, **kwargs):\\n \\\"\\\"\\\"\\n The result function, that wraps decorated function.\\n \\\"\\\"\\\"\\n return number * decorated_function(*args, **kwargs)\\n\\n return extended_func\",\n \"def get_function(self):\\n return self.element.get_basis_functions()[self.n]\",\n \"def _wrap_in_generator(func, source, namer, overload):\\n\\n nonlocals = []\\n\\n for var in six.get_function_code(func).co_freevars:\\n # We must generate dummy vars so the generated function has the same closure\\n # as the original function.\\n free_template = 'var = None'\\n nonlocal_node = templates.replace(free_template, var=var)\\n nonlocals.extend(nonlocal_node)\\n\\n gen_fun_name = namer.new_symbol('gen_fun', set())\\n template = \\\"\\\"\\\"\\n def gen_fun(overload):\\n nonlocals\\n\\n program\\n\\n return f_name\\n \\\"\\\"\\\"\\n\\n ret = templates.replace(\\n template,\\n gen_fun=gen_fun_name,\\n nonlocals=nonlocals,\\n overload=overload.symbol_name,\\n program=source,\\n f_name=func.__name__)\\n\\n converted_module, _ = parsing.ast_to_object(ret)\\n outer_func = getattr(converted_module, gen_fun_name)\\n return outer_func(overload.module)\",\n \"def firstFunction(self):\",\n \"def get_function(self):\\n return Gumtree.gumtree.getFunction()\",\n \"def generate(self):\\n pass\",\n \"def generate(self):\\n pass\",\n \"def generate(self):\\n pass\",\n \"def __compile__(self) -> types.FunctionType:\\n code = {}\\n exec(compile(self.__build_method__(), '<string>', 'exec'), code)\\n return code[\\\"solve\\\"]\",\n \"def fn(self):\\n return \\\"Hello\\\"\",\n \"def get_a_func(self, is_training=False, reuse=False):\\n return functools.partial(self.a_func,\\n num_actions=self._action_size,\\n scope='a_func',\\n reuse=reuse,\\n is_training=is_training)\",\n \"def _random_function(self, random_state):\\n return random_state.rand\",\n \"def __call__(self, function: FuncSpeechArg):\\n self._add_attr(function)\\n return function\",\n \"def _gen_code(self):\\r\\n #TODO: maybe generate one C function only to save compile time? Also easier to take that as a basis and hand craft other covariances??\\r\\n\\r\\n #generate c functions from sympy objects \\r\\n argument_sequence = self._sp_x+self._sp_z+self._sp_theta\\r\\n code_list = [('k',self._sp_k)]\\r\\n # gradients with respect to covariance input\\r\\n code_list += [('dk_d%s'%x.name,dx) for x,dx in zip(self._sp_x,self._sp_dk_dx)]\\r\\n # gradient with respect to parameters\\r\\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta,self._sp_dk_dtheta)]\\r\\n # gradient with respect to multiple output parameters\\r\\n if self.output_dim > 1:\\r\\n argument_sequence += self._sp_theta_i + self._sp_theta_j\\r\\n code_list += [('dk_d%s'%theta.name,dtheta) for theta,dtheta in zip(self._sp_theta_i,self._sp_dk_dtheta_i)]\\r\\n (foo_c,self._function_code), (foo_h,self._function_header) = \\\\\\r\\n codegen(code_list, \\\"C\\\",'foobar',argument_sequence=argument_sequence)\\r\\n #put the header file where we can find it\\r\\n f = file(os.path.join(tempfile.gettempdir(),'foobar.h'),'w')\\r\\n f.write(self._function_header)\\r\\n f.close()\\r\\n\\r\\n # Substitute any known derivatives which sympy doesn't compute\\r\\n self._function_code = re.sub('DiracDelta\\\\(.+?,.+?\\\\)','0.0',self._function_code)\\r\\n\\r\\n\\r\\n ############################################################\\r\\n # This is the basic argument construction for the C code. #\\r\\n ############################################################\\r\\n \\r\\n arg_list = ([\\\"X2(i, %s)\\\"%x.name[2:] for x in self._sp_x]\\r\\n + [\\\"Z2(j, %s)\\\"%z.name[2:] for z in self._sp_z])\\r\\n\\r\\n # for multiple outputs need to also provide these arguments reversed.\\r\\n if self.output_dim>1:\\r\\n reverse_arg_list = list(arg_list)\\r\\n reverse_arg_list.reverse()\\r\\n\\r\\n # Add in any 'shared' parameters to the list.\\r\\n param_arg_list = [shared_params.name for shared_params in self._sp_theta]\\r\\n arg_list += param_arg_list\\r\\n\\r\\n precompute_list=[]\\r\\n if self.output_dim > 1:\\r\\n reverse_arg_list+=list(param_arg_list)\\r\\n split_param_arg_list = [\\\"%s1(%s)\\\"%(theta.name[:-2].upper(),index) for index in ['ii', 'jj'] for theta in self._sp_theta_i]\\r\\n split_param_reverse_arg_list = [\\\"%s1(%s)\\\"%(theta.name[:-2].upper(),index) for index in ['jj', 'ii'] for theta in self._sp_theta_i]\\r\\n arg_list += split_param_arg_list\\r\\n reverse_arg_list += split_param_reverse_arg_list\\r\\n # Extract the right output indices from the inputs.\\r\\n c_define_output_indices = [' '*16 + \\\"int %s=(int)%s(%s, %i);\\\"%(index, var, index2, self.input_dim-1) for index, var, index2 in zip(['ii', 'jj'], ['X2', 'Z2'], ['i', 'j'])]\\r\\n precompute_list += c_define_output_indices\\r\\n reverse_arg_string = \\\", \\\".join(reverse_arg_list)\\r\\n arg_string = \\\", \\\".join(arg_list)\\r\\n precompute_string = \\\"\\\\n\\\".join(precompute_list)\\r\\n\\r\\n # Code to compute argments string needed when only X is provided.\\r\\n X_arg_string = re.sub('Z','X',arg_string)\\r\\n # Code to compute argument string when only diagonal is required.\\r\\n diag_arg_string = re.sub('int jj','//int jj',X_arg_string)\\r\\n diag_arg_string = re.sub('j','i',diag_arg_string)\\r\\n if precompute_string == '':\\r\\n # if it's not multioutput, the precompute strings are set to zero\\r\\n diag_precompute_string = ''\\r\\n diag_precompute_replace = ''\\r\\n else:\\r\\n # for multioutput we need to extract the index of the output form the input.\\r\\n diag_precompute_string = precompute_list[0]\\r\\n diag_precompute_replace = precompute_list[1]\\r\\n \\r\\n\\r\\n # Here's the code to do the looping for K\\r\\n self._K_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _K_code\\r\\n // Code for computing the covariance function.\\r\\n int i;\\r\\n int j;\\r\\n int N = target_array->dimensions[0];\\r\\n int num_inducing = target_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N;i++){\\r\\n for (j=0;j<num_inducing;j++){\\r\\n%s\\r\\n //target[i*num_inducing+j] = \\r\\n TARGET2(i, j) += k(%s);\\r\\n }\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(precompute_string,arg_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n\\r\\n self._K_code_X = \\\"\\\"\\\"\\r\\n // _K_code_X\\r\\n // Code for computing the covariance function.\\r\\n int i;\\r\\n int j;\\r\\n int N = target_array->dimensions[0];\\r\\n int num_inducing = target_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N;i++){\\r\\n %s // int ii=(int)X2(i, 1);\\r\\n TARGET2(i, i) += k(%s);\\r\\n for (j=0;j<i;j++){\\r\\n %s //int jj=(int)X2(j, 1);\\r\\n double kval = k(%s); //double kval = k(X2(i, 0), shared_lengthscale, LENGTHSCALE1(ii), SCALE1(ii));\\r\\n TARGET2(i, j) += kval;\\r\\n TARGET2(j, i) += kval;\\r\\n }\\r\\n }\\r\\n /*%s*/\\r\\n \\\"\\\"\\\"%(diag_precompute_string, diag_arg_string, re.sub('Z2', 'X2', diag_precompute_replace), X_arg_string,str(self._sp_k)) #adding a string representation forces recompile when needed\\r\\n\\r\\n # Code to do the looping for Kdiag\\r\\n self._Kdiag_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _Kdiag_code\\r\\n // Code for computing diagonal of covariance function.\\r\\n int i;\\r\\n int N = target_array->dimensions[0];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for\\r\\n for (i=0;i<N;i++){\\r\\n %s\\r\\n //target[i] =\\r\\n TARGET1(i)=k(%s);\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(diag_precompute_string,diag_arg_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n\\r\\n # Code to compute gradients\\r\\n grad_func_list = []\\r\\n if self.output_dim>1:\\r\\n grad_func_list += c_define_output_indices\\r\\n grad_func_list += [' '*16 + 'TARGET1(%i+ii) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, arg_string) for i, theta in enumerate(self._sp_theta_i)]\\r\\n grad_func_list += [' '*16 + 'TARGET1(%i+jj) += PARTIAL2(i, j)*dk_d%s(%s);'%(self.num_shared_params+i*self.output_dim, theta.name, reverse_arg_string) for i, theta in enumerate(self._sp_theta_i)]\\r\\n grad_func_list += ([' '*16 + 'TARGET1(%i) += PARTIAL2(i, j)*dk_d%s(%s);'%(i,theta.name,arg_string) for i,theta in enumerate(self._sp_theta)])\\r\\n grad_func_string = '\\\\n'.join(grad_func_list) \\r\\n\\r\\n self._dK_dtheta_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dK_dtheta_code\\r\\n // Code for computing gradient of covariance with respect to parameters.\\r\\n int i;\\r\\n int j;\\r\\n int N = partial_array->dimensions[0];\\r\\n int num_inducing = partial_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N;i++){\\r\\n for (j=0;j<num_inducing;j++){\\r\\n%s\\r\\n }\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(grad_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") # adding a string representation forces recompile when needed\\r\\n\\r\\n\\r\\n # Code to compute gradients for Kdiag TODO: needs clean up\\r\\n diag_grad_func_string = re.sub('Z','X',grad_func_string,count=0)\\r\\n diag_grad_func_string = re.sub('int jj','//int jj',diag_grad_func_string)\\r\\n diag_grad_func_string = re.sub('j','i',diag_grad_func_string)\\r\\n diag_grad_func_string = re.sub('PARTIAL2\\\\(i, i\\\\)','PARTIAL1(i)',diag_grad_func_string)\\r\\n self._dKdiag_dtheta_code =\\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dKdiag_dtheta_code\\r\\n // Code for computing gradient of diagonal with respect to parameters.\\r\\n int i;\\r\\n int N = partial_array->dimensions[0];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n for (i=0;i<N;i++){\\r\\n %s\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(diag_grad_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n\\r\\n # Code for gradients wrt X, TODO: may need to deal with special case where one input is actually an output.\\r\\n gradX_func_list = []\\r\\n if self.output_dim>1:\\r\\n gradX_func_list += c_define_output_indices\\r\\n gradX_func_list += [\\\"TARGET2(i, %i) += PARTIAL2(i, j)*dk_dx_%i(%s);\\\"%(q,q,arg_string) for q in range(self._real_input_dim)]\\r\\n gradX_func_string = \\\"\\\\n\\\".join(gradX_func_list)\\r\\n\\r\\n self._dK_dX_code = \\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dK_dX_code\\r\\n // Code for computing gradient of covariance with respect to inputs.\\r\\n int i;\\r\\n int j;\\r\\n int N = partial_array->dimensions[0];\\r\\n int num_inducing = partial_array->dimensions[1];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n //#pragma omp parallel for private(j)\\r\\n for (i=0;i<N; i++){\\r\\n for (j=0; j<num_inducing; j++){\\r\\n %s\\r\\n }\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(gradX_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a string representation forces recompile when needed\\r\\n \\r\\n\\r\\n diag_gradX_func_string = re.sub('Z','X',gradX_func_string,count=0)\\r\\n diag_gradX_func_string = re.sub('int jj','//int jj',diag_gradX_func_string)\\r\\n diag_gradX_func_string = re.sub('j','i',diag_gradX_func_string)\\r\\n diag_gradX_func_string = re.sub('PARTIAL2\\\\(i, i\\\\)','2*PARTIAL1(i)',diag_gradX_func_string)\\r\\n\\r\\n # Code for gradients of Kdiag wrt X\\r\\n self._dKdiag_dX_code= \\\\\\r\\n \\\"\\\"\\\"\\r\\n // _dKdiag_dX_code\\r\\n // Code for computing gradient of diagonal with respect to inputs.\\r\\n int N = partial_array->dimensions[0];\\r\\n int input_dim = X_array->dimensions[1];\\r\\n for (int i=0;i<N; i++){\\r\\n %s\\r\\n }\\r\\n %s\\r\\n \\\"\\\"\\\"%(diag_gradX_func_string,\\\"/*\\\"+str(self._sp_k)+\\\"*/\\\") #adding a\\r\\n # string representation forces recompile when needed Get rid\\r\\n # of Zs in argument for diagonal. TODO: Why wasn't\\r\\n # diag_func_string called here? Need to check that.\\r\\n #self._dKdiag_dX_code = self._dKdiag_dX_code.replace('Z[j', 'X[i')\\r\\n\\r\\n # Code to use when only X is provided. \\r\\n self._dK_dtheta_code_X = self._dK_dtheta_code.replace('Z[', 'X[')\\r\\n self._dK_dX_code_X = self._dK_dX_code.replace('Z[', 'X[').replace('+= PARTIAL2(', '+= 2*PARTIAL2(') \\r\\n self._dK_dtheta_code_X = self._dK_dtheta_code_X.replace('Z2(', 'X2(')\\r\\n self._dK_dX_code_X = self._dK_dX_code_X.replace('Z2(', 'X2(')\\r\\n\\r\\n\\r\\n #TODO: insert multiple functions here via string manipulation\\r\\n #TODO: similar functions for psi_stats\\r\",\n \"def a_function_of_mine():\\n return 'result'\",\n \"def python_function(self):\\n return self._python_function # pylint: disable=protected-access\",\n \"def function(self):\\n return self.devicefuncs[self._funcname]\",\n \"def func(cls):\\n return cls.get_wrapper()(cls.callable)\",\n \"def special_def(self, form):\\n if not len(form) >= 3:\\n raise SyntaxError(\\\"Not enough forms in %s\\\" % form)\\n if not isinstance(form[1], Form):\\n raise SyntaxError(\\\"Expected a list of [funname args...]\\\")\\n\\n doc, code = self._getDocAndCode(form[2:])\\n #print \\\"GOT\\\", code\\n #code.nodes[-1] = ast.Return(code.nodes[-1])\\n args = [x.name for x in form[1][1:]]\\n \\n magicode = self._getMagicCodeForArgs(args)\\n \\n return ast.Function(None, form[1][0].name, args, [], magicode, doc, code)\",\n \"def gen_vee_func(self):\\n dual_func = self.dual_func\\n omt_func = self.omt_func\\n @numba.njit\\n def vee(aval, bval):\\n return dual_func(omt_func(dual_func(aval), dual_func(bval)))\\n return vee\",\n \"def function(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"function\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72852004","0.7195862","0.7117405","0.70892036","0.7076999","0.6858654","0.6826619","0.67727506","0.67657286","0.6740471","0.67363507","0.67158663","0.6688514","0.6664095","0.665405","0.6650802","0.66507447","0.66498697","0.6646827","0.6641116","0.66322","0.6628116","0.6605331","0.6566666","0.65216374","0.65061164","0.6494242","0.6423469","0.6393869","0.6388995","0.6386088","0.636487","0.6363463","0.6362926","0.636123","0.6336199","0.62982345","0.6289591","0.6273761","0.6271196","0.62702817","0.62702817","0.6264745","0.625405","0.6233895","0.62257063","0.6218348","0.6198589","0.6193492","0.61833763","0.6165905","0.61573565","0.61421365","0.61402035","0.61218953","0.61130136","0.6112212","0.6109135","0.61083394","0.6096901","0.6090769","0.60752547","0.607438","0.607179","0.6040324","0.60391784","0.6035885","0.60334736","0.6032388","0.60215616","0.6015523","0.60088277","0.60039526","0.60039526","0.60039526","0.5992931","0.59831357","0.5982573","0.59715974","0.59684855","0.59639835","0.5962034","0.5958344","0.59559083","0.59478813","0.5937469","0.5937469","0.5937469","0.59318143","0.59228337","0.591062","0.59032464","0.5892627","0.58806646","0.58761746","0.5873044","0.5870871","0.5866711","0.5857052","0.58566797","0.5849914"],"string":"[\n \"0.72852004\",\n \"0.7195862\",\n \"0.7117405\",\n \"0.70892036\",\n \"0.7076999\",\n \"0.6858654\",\n \"0.6826619\",\n \"0.67727506\",\n \"0.67657286\",\n \"0.6740471\",\n \"0.67363507\",\n \"0.67158663\",\n \"0.6688514\",\n \"0.6664095\",\n \"0.665405\",\n \"0.6650802\",\n \"0.66507447\",\n \"0.66498697\",\n \"0.6646827\",\n \"0.6641116\",\n \"0.66322\",\n \"0.6628116\",\n \"0.6605331\",\n \"0.6566666\",\n \"0.65216374\",\n \"0.65061164\",\n \"0.6494242\",\n \"0.6423469\",\n \"0.6393869\",\n \"0.6388995\",\n \"0.6386088\",\n \"0.636487\",\n \"0.6363463\",\n \"0.6362926\",\n \"0.636123\",\n \"0.6336199\",\n \"0.62982345\",\n \"0.6289591\",\n \"0.6273761\",\n \"0.6271196\",\n \"0.62702817\",\n \"0.62702817\",\n \"0.6264745\",\n \"0.625405\",\n \"0.6233895\",\n \"0.62257063\",\n \"0.6218348\",\n \"0.6198589\",\n \"0.6193492\",\n \"0.61833763\",\n \"0.6165905\",\n \"0.61573565\",\n \"0.61421365\",\n \"0.61402035\",\n \"0.61218953\",\n \"0.61130136\",\n \"0.6112212\",\n \"0.6109135\",\n \"0.61083394\",\n \"0.6096901\",\n \"0.6090769\",\n \"0.60752547\",\n \"0.607438\",\n \"0.607179\",\n \"0.6040324\",\n \"0.60391784\",\n \"0.6035885\",\n \"0.60334736\",\n \"0.6032388\",\n \"0.60215616\",\n \"0.6015523\",\n \"0.60088277\",\n \"0.60039526\",\n \"0.60039526\",\n \"0.60039526\",\n \"0.5992931\",\n \"0.59831357\",\n \"0.5982573\",\n \"0.59715974\",\n \"0.59684855\",\n \"0.59639835\",\n \"0.5962034\",\n \"0.5958344\",\n \"0.59559083\",\n \"0.59478813\",\n \"0.5937469\",\n \"0.5937469\",\n \"0.5937469\",\n \"0.59318143\",\n \"0.59228337\",\n \"0.591062\",\n \"0.59032464\",\n \"0.5892627\",\n \"0.58806646\",\n \"0.58761746\",\n \"0.5873044\",\n \"0.5870871\",\n \"0.5866711\",\n \"0.5857052\",\n \"0.58566797\",\n \"0.5849914\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":871,"numItemsPerPage":100,"numTotalItems":95772,"offset":87100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTg4NjYxMywianRpIjoiMjAwYmMwNjItMjAwOC00OWZhLWE0MzEtYjJkZWE5NWQxNTYwIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU4OTAyMTMsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.1aZ6vn3GLwqLEdc3aJ1RGtDXbX9q55SwGDhtKErN7RKMrozkMCrASUbDuXCOYBRD1XncSLWSOAq5pPKxgtTACA","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 |
|---|---|---|---|---|---|---|
Method to return a single user item based on the user item's id and its user's id | def get_shoppinglist(self, user_id, item_id):
single_user = self.get_single_user(user_id)
for item in single_user['shopping_lists']:
if item['id'] == item_id:
return item | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_item(self, id: str, user: User) -> Optional[T]:",
"def get_item_with_id(self, uid):\n for item in self.get_items():\n if item.id == uid:\n return item\n\n return None",
"def read_item(\n *,\n db: Session = Depends(deps.get_db),\n id: int,\n current_us... | [
"0.81888264",
"0.74340504",
"0.74272496",
"0.7383298",
"0.736834",
"0.73598313",
"0.7240594",
"0.7074708",
"0.7013704",
"0.6996037",
"0.6929328",
"0.68309075",
"0.67663807",
"0.6757231",
"0.6750522",
"0.6712037",
"0.66984546",
"0.66922104",
"0.66691977",
"0.66645956",
"0.6620... | 0.7080669 | 7 |
Method to delete a user item based on its id and its user's id | def remove_shoppinglist(self, user_id, item_id):
single_user = self.get_single_user(user_id)
for item in single_user['shopping_lists']:
if item['id'] == int(item_id):
single_user['shopping_lists'].remove(item) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_item(self, id: str, user: User) -> bool:",
"def delete_item(self, item_id, user_id):\r\n item = self._db_manager.get_item(item_id)\r\n if item is None:\r\n flash(\"Invalid item.\")\r\n return\r\n if item[\"user_id\"] != user_id:\r\n flash(\"Only th... | [
"0.8827835",
"0.8003457",
"0.7913838",
"0.7846232",
"0.7707595",
"0.76937795",
"0.7643314",
"0.76206136",
"0.75877017",
"0.74724805",
"0.74564457",
"0.7368197",
"0.7362754",
"0.7349677",
"0.7290494",
"0.72537416",
"0.7233881",
"0.7227828",
"0.719459",
"0.71916765",
"0.7161109... | 0.0 | -1 |
Method to add shopping items to a shopping list | def add_shoppingitems(self, user_id, shoppinglist_id, name, quantity):
new_shoppingitem = ShoppingItem(name, quantity)
new_shoppingitem_details = new_shoppingitem.get_details()
user = self.get_single_user(user_id)
for shopinglist in user['shopping_lists']:
if shopinglist['id'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_item_to_shopping_list(shopping_list, item, quantity):\n shopping_list_items = ShoppingListItems.query.filter_by(shopping_list_id=shopping_list.id, item_id=item.id).first()\n if shopping_list_items is None:\n shopping_list_items = ShoppingListItems(shopping_list_id=shopping_list.id, item_id=ite... | [
"0.69891316",
"0.6971309",
"0.6909483",
"0.6886743",
"0.68709165",
"0.6862786",
"0.6772096",
"0.67416227",
"0.6698839",
"0.66877407",
"0.6674672",
"0.66226494",
"0.66226494",
"0.66226494",
"0.65921545",
"0.65899134",
"0.65749466",
"0.6560956",
"0.6547719",
"0.65255886",
"0.65... | 0.72290874 | 0 |
Method to get a single item from the shopping list | def get_shoppingitem(self, user_id, shoppinglist_id, item_id):
shoppinglist = self.get_shoppinglist(user_id, shoppinglist_id)
for item in shoppinglist['items']:
if item['id'] == item_id:
return item | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_item(item_id):\n return Item.query.filter_by(id=item_id).first()",
"def get_item(self, name: str) -> Optional[Item]:\n item = self.filter_items(name, limit=1)\n return item[0] if item else None",
"def get_item(self, call_number):\n return self.item_list.get(call_number)",
"def... | [
"0.72919077",
"0.7291454",
"0.7179455",
"0.7159581",
"0.715449",
"0.7142205",
"0.7142205",
"0.70436245",
"0.69442225",
"0.69362116",
"0.693477",
"0.6910595",
"0.6884364",
"0.68688667",
"0.67610484",
"0.67220116",
"0.67014426",
"0.6701249",
"0.66954094",
"0.6669914",
"0.660991... | 0.75183713 | 0 |
Method to delete an item from the shoppinglist | def remove_shoppingitem(self, user_id, shoppinglist_id, item_id):
shoppinglist = self.get_shoppinglist(user_id, shoppinglist_id)
for item in shoppinglist['items']:
if item['id'] == int(item_id):
shoppinglist['items'].remove(item) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_item(request, shoppinglist_id, item_id):\n Item.objects.filter(pk=item_id,\n shoppinglist__pantry__owner=request.user).delete()\n return redirect('shoppinglists.views.detail', shoppinglist_id)",
"def deleteItem(list,item):\n print \"I deleted this item:\", item\n lis... | [
"0.8030308",
"0.7621568",
"0.7593034",
"0.7562986",
"0.750939",
"0.7415289",
"0.73915005",
"0.7387138",
"0.7356343",
"0.73174816",
"0.73023534",
"0.7295307",
"0.7246188",
"0.72387516",
"0.71779037",
"0.7167007",
"0.7143311",
"0.71206284",
"0.71154463",
"0.70882845",
"0.708669... | 0.6691563 | 50 |
Method to indicate bought items | def buy_shoppingitem(self, user_id, shoppinglist_id, item_id):
item = self.get_shoppingitem(user_id, shoppinglist_id, item_id)
if not item['bought']:
item['bought'] = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def purchase(self, item_type):",
"def purchase_item(self):\r\n self.purchased_callback()\r\n self.status = 'purchased'\r\n self.fulfilled_time = datetime.now(pytz.utc)\r\n self.save()",
"async def _vis_buy(self, ctx, *args):\n if has_post_permission(ctx.guild.id, ctx.channel.... | [
"0.73451656",
"0.67821705",
"0.6600444",
"0.65148836",
"0.65054286",
"0.6455387",
"0.6421658",
"0.63444376",
"0.6324628",
"0.6315627",
"0.63023406",
"0.6289282",
"0.628285",
"0.62249106",
"0.6185769",
"0.6153408",
"0.6136711",
"0.6134128",
"0.60930735",
"0.6054386",
"0.605315... | 0.75839543 | 0 |
If your looking at this and thinking 'why in gods name are you doing that', realize that this is required by the android app which I have no controll over. This is flat out dumb. | def get_legacy_pins():
return "2018-08-29 11:15:32.841\n" + json.dumps(
list(map(translate_to_old, pin_dao.get_all())),
indent = 4
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def think(self):\n pass",
"def support(self):",
"def degibber(self):",
"def _(a):\n\ta.internal.device.google_experience = not getattr(a.internal.settings,\n\t\t\t\t'False',\n\t\t\t\t'charge_only_mode' in a.device.ls('/system/bin'))\n\tif a.internal.device.google_experience:\n\t\tandroid.log.info(TAG,... | [
"0.52237844",
"0.5203687",
"0.5098423",
"0.5072103",
"0.5052208",
"0.50287414",
"0.49808693",
"0.4959477",
"0.49032933",
"0.48983845",
"0.4890433",
"0.48784813",
"0.48569018",
"0.48569018",
"0.48456803",
"0.48218966",
"0.48055628",
"0.47725958",
"0.476807",
"0.47618002",
"0.4... | 0.0 | -1 |
Parse a directory of HTML pages and check for links to other pages. Return a dictionary where each key is a page, and values are a list of all other pages in the corpus that are linked to by the page. | def crawl(directory):
pages = dict()
# Extract all links from HTML files
for filename in os.listdir(directory):
if not filename.endswith(".html"):
continue
with open(os.path.join(directory, filename)) as f:
contents = f.read()
links = re.findall(r"<a\s+(?... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def linked_pages(corpus, page):\n pages = list()\n\n for link in corpus:\n if page in corpus[link]:\n pages.append(link)\n\n if not corpus[link]:\n pages.append(link)\n\n return pages",
"def parse_page(url):\n page_content = download_page(url)\n if page_content:... | [
"0.6817799",
"0.6559882",
"0.6514604",
"0.64565563",
"0.6432747",
"0.62858313",
"0.6256209",
"0.6251121",
"0.614946",
"0.607668",
"0.60331887",
"0.60087353",
"0.5999504",
"0.5984497",
"0.5887131",
"0.58262646",
"0.58190536",
"0.5814247",
"0.5813702",
"0.5809713",
"0.5790241",... | 0.8283629 | 7 |
Return a probability distribution over which page to visit next, given a current page. With probability `damping_factor`, choose a link at random linked to by `page`. With probability `1 damping_factor`, choose a link at random chosen from all pages in the corpus. | def transition_model(corpus, page, damping_factor):
prob_dist = defaultdict(float)
corpus_len = len(corpus)
if not corpus[page]:
for corpus_page in corpus:
prob_dist[corpus_page] += 1/corpus_len
return prob_dist
len_linked_pages = len(corpus[page])
for linked_page in cor... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transition_model(corpus, page, damping_factor):\n distribution = dict() #Create a dictionary for the probability distribution\n all_pages = []\n links = list(corpus[page]) #All pages linked by current page\n for u in corpus:\n all_pages.append(u)\n\n #If the current page does not link to ... | [
"0.7992964",
"0.77270436",
"0.764785",
"0.7500536",
"0.72686094",
"0.70465213",
"0.6915432",
"0.68950415",
"0.6844223",
"0.6782304",
"0.6755477",
"0.6724492",
"0.66375583",
"0.6618151",
"0.6553851",
"0.65046436",
"0.63941073",
"0.63314575",
"0.6278812",
"0.62436855",
"0.62332... | 0.7451512 | 4 |
Return PageRank values for each page by sampling `n` pages according to transition model, starting with a page at random. Return a dictionary where keys are page names, and values are their estimated PageRank value (a value between 0 and 1). All PageRank values should sum to 1. | def sample_pagerank(corpus, damping_factor, n):
corpus_length = len(corpus)
# First sample
previous_page_rank = defaultdict(lambda: 1/corpus_length)
# All remaining samples
# Choose a previous page, then add transition probabilities
# Loop over remaining previous pages
for sample in range(1... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sample_pagerank(corpus, damping_factor, n):\n\n PageRank = dict()\n\n # set ranks of all pages to 0\n for page in corpus:\n PageRank[page] = 0.0\n\n # choose the first sample page at random\n sample = random.choice(list(corpus.keys()))\n PageRank[sample] += 1\n\n # to go to the next... | [
"0.75169337",
"0.6918657",
"0.6863597",
"0.6627731",
"0.6537425",
"0.65101093",
"0.6433924",
"0.6317246",
"0.60648733",
"0.5941704",
"0.58936095",
"0.58452195",
"0.57045394",
"0.56618065",
"0.56023586",
"0.55996376",
"0.55472916",
"0.552801",
"0.54974765",
"0.5457652",
"0.542... | 0.67144537 | 3 |
Return PageRank values for each page by iteratively updating PageRank values until convergence. Return a dictionary where keys are page names, and values are their estimated PageRank value (a value between 0 and 1). All PageRank values should sum to 1. | def iterate_pagerank(corpus, damping_factor):
# Set initial values to choosing a page randomly
corpus_length = len(corpus)
prev_iterated_page_rank = defaultdict(lambda: 1/corpus_length)
max_abs_difference = inf
while max_abs_difference > 0.001:
max_iter_diff = -inf
next_iterated_page... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def PageRank(start):\n probs = {}\n probs[start] = 1\n num_page_rank_iterations = 3\n maximum = 25\n\n PageRankProbs = PageRankHelper(start,\n probs,\n num_page_rank_iterations)\n\n PageRankProbs = zip(PageRankProbs.iterkeys(),\n... | [
"0.71327984",
"0.7025723",
"0.68315536",
"0.67477626",
"0.6581035",
"0.6356272",
"0.6345436",
"0.6294455",
"0.6282516",
"0.6247623",
"0.62171674",
"0.6167306",
"0.61651623",
"0.61310714",
"0.5901231",
"0.5877613",
"0.57514936",
"0.5736412",
"0.56930906",
"0.5603937",
"0.55962... | 0.6230429 | 10 |
MAX SIZE OF RANDOM INTEGER RANGE TO GENERATE ALL POSSIBLE PERMS is 2080 | def __permute(l,opts):
MAX_RAND_SIZE = 2080
if (len(l)/3 < MAX_RAND_SIZE):
rd.shuffle(l)
else:
sys.stderr.write(\
"{}:{}: Valid Random Permutation Range Exceeded."\
.format(opts.progname,permute.__name__))
opts.perror+=1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_digits(generator, size) :\n return [int(generator.random()*10) for i in range(size)]",
"def create_num_size(size):\n rand.seed(datetime.now())\n num = ''\n size = rand.choice(size) \n for _ in range(size):\n a = rand.randint(0,9)\n num += str(a)\n return num",
"def ... | [
"0.7028499",
"0.67332536",
"0.6693746",
"0.6675463",
"0.66336054",
"0.6608696",
"0.657713",
"0.6521843",
"0.6511546",
"0.6500632",
"0.64960986",
"0.6493789",
"0.6480264",
"0.6464707",
"0.6453372",
"0.63872236",
"0.6383089",
"0.63741326",
"0.6346072",
"0.6323319",
"0.6305728",... | 0.60394675 | 35 |
Initialisation of a _Config instance. | def __init__(self, *args, **kwargs):
super().__init__()
self._cfg = ConfigDict() # current configuration
self._default_config = ConfigDict() # default configuration
self._temp_config = OrderedDict() # temporary configuration
self._path = Path() # current configuration pa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_config(self):\n pass",
"def init_config() -> Config:\n ...",
"def _init_config_(self):\n self._config= {}",
"def initialize(self, **kwargs):\n\n # Defining the configuration object\n self.config = kwargs.get('config')",
"def Init(self, config):\r\n pass",
"def _... | [
"0.7909576",
"0.7742302",
"0.7696239",
"0.7674185",
"0.75723463",
"0.7561906",
"0.74977136",
"0.7456496",
"0.7397632",
"0.7368958",
"0.7259326",
"0.7254477",
"0.72241116",
"0.72157997",
"0.7205846",
"0.7189471",
"0.7189471",
"0.7183831",
"0.71579534",
"0.71477437",
"0.7131284... | 0.7987772 | 0 |
Edit attributes of the configuration. | def edit(self, **kwargs):
for attr in self.EDITABLE_ATTR:
kwarg = kwargs.pop(attr, self._WILDCARD)
if kwarg is not self._WILDCARD:
setattr(self, attr, kwarg)
logger.debug("Attribute '{}' changed to '{}'.".format(attr, kwarg))
for p_attr in ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_attributes(self, attributes):\n self.attributes = dict(attributes) # overwrite the existing registry of attributes with the input attributes",
"def set_attributes(self, attributes):\n self.attributes = dict(attributes) # overwrite the existing registry of attributes with the input attribu... | [
"0.6473589",
"0.6473589",
"0.6473589",
"0.63702786",
"0.63045835",
"0.6293869",
"0.6224746",
"0.62141687",
"0.61229956",
"0.61122084",
"0.61088306",
"0.6079231",
"0.60124195",
"0.60124195",
"0.60038865",
"0.6000448",
"0.59741896",
"0.5974063",
"0.5967706",
"0.5967706",
"0.596... | 0.75753456 | 0 |
If the section doesn't exist and search_in_default_config, append the section from default config to current configuration | def _check_section(self, section: Union[str, list], search_in_default_config: bool = None):
section = None if section is None else ConfigDict.TO_KEY_FUNC(section)
search_in_default_config = self._search_in_default_config if search_in_default_config is None \
else search_in_default_config
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_config(self, section=None):\r\n self.set_section(section, search_in_default_config=True)",
"def overwrite(section: str, data: any) -> None:\n\toverwriteDict[section] = data\n\tlogger.debug(f'Overwritten config {section}!')",
"def search_for_config(self, cfg_section, options):\n for key, ... | [
"0.68606806",
"0.6550262",
"0.65217954",
"0.6469845",
"0.6428516",
"0.6379521",
"0.6358503",
"0.62302405",
"0.6228921",
"0.61324304",
"0.6030926",
"0.60255",
"0.5983904",
"0.59709",
"0.59571606",
"0.59264976",
"0.5877952",
"0.5862359",
"0.5850703",
"0.5835888",
"0.5816391",
... | 0.7271659 | 0 |
Returns the SectionDict associated to the 'section' key | def get_section(self, section=None, set_section=False, add_section=False, search_in_default_config=None):
section = self._check_section(section, search_in_default_config=search_in_default_config)
return self._cfg.get_section(section=section, set_section=set_section, add_section=add_section) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_dict(self, section):\n\t\t\n\t\tdct = {}\n\t\t\n\t\tfor name, value in self.items(section):\n\t\t\tdct[name] = self.parse_value(value)\n\t\t\n\t\treturn dct",
"def section(self):\n return SECTION_NAME_TO_SECTION[self.section_name]",
"def get_options_for_section(section: str) -> Dict[str, Any]:\n w... | [
"0.7338172",
"0.70201725",
"0.69332033",
"0.6904912",
"0.68920475",
"0.68613344",
"0.6850933",
"0.66979533",
"0.6686725",
"0.668527",
"0.6677349",
"0.66024166",
"0.65857536",
"0.6570939",
"0.65477306",
"0.65411085",
"0.64621943",
"0.6413999",
"0.6413999",
"0.6377982",
"0.6362... | 0.55626315 | 59 |
alias of set_section, with search_in_default_config argument True by default. | def load_config(self, section=None):
self.set_section(section, search_in_default_config=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def configure(self, section):",
"def search_for_config(self, cfg_section, options):\n for key, default in options.items():\n val = default\n if key in cfg_section:\n val = cfg_section[key]\n setattr(self, key, val)",
"def _check_section(self, section: Unio... | [
"0.6789469",
"0.66695064",
"0.6498293",
"0.6160742",
"0.60437703",
"0.6006598",
"0.59721696",
"0.59567016",
"0.5919255",
"0.5820273",
"0.57651395",
"0.57304776",
"0.57055175",
"0.569853",
"0.56252676",
"0.5622563",
"0.5590487",
"0.5496037",
"0.5474919",
"0.54692334",
"0.54423... | 0.6786406 | 1 |
alias to _cfg attribute | def config(self, config_dict):
self._cfg.config = config_dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def config( **kwargs ):",
"def configuration():",
"def config(self, **kw):\n self.cfg_fixture.config(**kw)",
"def config():",
"def config():",
"def config(self) -> NamedTuple:",
"def set_config(self, cfg):\n\n cfg.add_section(self.name)\n for attr, value in self.__dict__.items():\n... | [
"0.71776825",
"0.685836",
"0.6824247",
"0.67317116",
"0.67317116",
"0.6731125",
"0.6682881",
"0.66780627",
"0.66780627",
"0.66780627",
"0.65280193",
"0.64987534",
"0.6493411",
"0.6397842",
"0.63869405",
"0.63869405",
"0.635186",
"0.6324506",
"0.6317438",
"0.6309337",
"0.62967... | 0.0 | -1 |
Load configuration from file. If forceload, reload_default values on error.. | def load(self, path=None, force_load=None, auto_cast=None, load_empty=None, merge_how='right'):
path = self._path if path is None else Path(path)
auto_cast = self._auto_cast if auto_cast is None else auto_cast
force_load = self._force_load if force_load is None else force_load
load_e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(self, cfgfile, force_reload=False, failonerror=True,\n replace_keys={}):\n realpath = None\n if os.path.exists(cfgfile):\n realpath = cfgfile\n else:\n new_p = self._findConfigPath(cfgfile)\n if new_p:\n realpath = new_p\n ... | [
"0.7139778",
"0.6983545",
"0.69751984",
"0.6963302",
"0.6923232",
"0.6894999",
"0.68552387",
"0.68206865",
"0.6814341",
"0.6757191",
"0.6630725",
"0.66274244",
"0.6623084",
"0.6610858",
"0.66084945",
"0.6578569",
"0.65465844",
"0.64928377",
"0.64717007",
"0.6463129",
"0.64572... | 0.7279285 | 0 |
Set path and config to default values. If write is True, overwrite default file with default configuration. | def reload_default(self, write=True, backup=True, how='right', how_section=None, sections=None):
# self._cfg = self.default_config.deepcopy()
self._path = self._default_path.copy()
dico = self.default_config.deepcopy()
sections = {sections} if isinstance(sections, str) else sections
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _write_default_config(self, force=False):\n\t\t\n\t\tif self.configfilepath is not None:\n\t\t\tlogger.debug(\"You use the existing config file %s, I don't have to write one.\" % \\\n (self._get_config_filepath()))\n\t\t\treturn\n\t\t\n\t\tif force or not os.path.exists(... | [
"0.66851825",
"0.6599315",
"0.6573214",
"0.63652515",
"0.6331893",
"0.62328666",
"0.62254226",
"0.62060577",
"0.6150296",
"0.6066432",
"0.60447663",
"0.5919648",
"0.5907546",
"0.58950347",
"0.58055705",
"0.576085",
"0.5756444",
"0.575341",
"0.5591363",
"0.5586188",
"0.5564079... | 0.6801692 | 0 |
Returns a config_dict read from a INI file. | def read_config(cls, path, auto_cast=True, anomaly_flag='warning'):
# WARNING: No check of input arguments !
# Read the configuration file with configparser
config_parser = configparser.ConfigParser()
try:
config_parser.read(path, encoding=ENCODING)
except (conf... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_ini_file_into_dict(filename):\n output = {}\n\n INIfile = SafeConfigParser()\n result = INIfile.read(filename) # returns an empty list if file error\n if result == []:\n raise IOError\n\n #iterate through INI file and build dictionary\n for section_name in INIfile.sections():\n ... | [
"0.8019814",
"0.7851325",
"0.7706471",
"0.74429536",
"0.74194014",
"0.7389865",
"0.7376074",
"0.7328146",
"0.7315623",
"0.7299748",
"0.72546816",
"0.7174758",
"0.7162111",
"0.714674",
"0.70953774",
"0.70951605",
"0.70395404",
"0.7037581",
"0.70244175",
"0.7005851",
"0.6988791... | 0.0 | -1 |
Implement trajectory generator for your manipulator. Positional trajectory should be a 3rd degree polynomial going from an initial state q_0 to desired state q_k. Remember to derive the first and second derivative of it also. Use following formula for the polynomial from the instruction. | def generate(self, t):
t /= self.T
q = self.a_3 * t**3 + self.a_2 * t**2 * (1 - t) + self.a_1 * t * (1 - t)**2 + self.a_0 * (1 - t)**3
q_dot = (t**2)*(((-3)*self.a_0+3*self.a_1-3*self.a_2+3*self.a_3))+t*(6*self.a_0-4*self.a_1+2*self.a_2)+self.a_1
q_ddot = t*(((-6)*self.a_0+6*self.a_1-6*s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def quintic_trajectory_planning(q0, qf, qd0, qdf, qdd0, qddf, m = 100):\n n = q0.shape[0]\n\n # Polynomial Parameters\n a0 = np.copy(q0)\n a1 = np.copy(qd0) \n a2 = np.copy(qdd0) / 2\n a3 = (20 * qf - 20 * q0 - 8 * qdf - 12 * qd0 - 3 * qdd0 + qddf) / 2\n a4 = (30 * q0 - 30 * qf + 14 * qdf + 16... | [
"0.66870165",
"0.6496875",
"0.6068087",
"0.5954736",
"0.5872611",
"0.5806479",
"0.5782105",
"0.57541937",
"0.56382334",
"0.5616875",
"0.55826694",
"0.5577361",
"0.5566148",
"0.555733",
"0.552018",
"0.54858065",
"0.5483865",
"0.54755336",
"0.545013",
"0.5429541",
"0.5416966",
... | 0.58015233 | 6 |
Takes a list of dictionaries as input and outputs a CSV file. | def dict2csv(dictlist, csvfile):
f = open(csvfile, 'wb')
fieldnames = dictlist[0].keys()
csvwriter = csv.DictWriter(f, delimiter=',', fieldnames=fieldnames)
csvwriter.writerow(dict((fn, fn) for fn in fieldnames))
for row in dictlist:
csvwriter.writerow(row)
fn.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_csv(list_dicts, file_name):\n # We assume that all the dictionaries have the same keys\n fieldnames = list_dicts[0].keys()\n\n with open(file_name, 'w') as output_file:\n dict_writer = csv.DictWriter(output_file, fieldnames)\n dict_writer.writeheader()\n dict_writer.writerows(l... | [
"0.82183886",
"0.8148236",
"0.7516159",
"0.7435449",
"0.7253285",
"0.7222639",
"0.72080976",
"0.7179089",
"0.7170781",
"0.71316403",
"0.7119527",
"0.71007425",
"0.7058554",
"0.7034148",
"0.70299006",
"0.70035684",
"0.6990922",
"0.69674456",
"0.6953955",
"0.6924046",
"0.686764... | 0.78628516 | 2 |
No parameters have been implemented yet | def list_permissions(self, catalog_id: str) -> List[Dict[str, Any]]:
return self.grants[catalog_id] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parameters(self):",
"def params():\n raise NotImplementedError",
"def parameters(self):\n pass",
"def Parameters():\n\n raise NotImplementedError()",
"def define_parameters(self):",
"def __call__(self):\n raise NotImplementedError",
"def params(self):\n pass",
"def __ca... | [
"0.75948536",
"0.7268151",
"0.7175833",
"0.7131094",
"0.711142",
"0.70831674",
"0.70758194",
"0.7006704",
"0.7006704",
"0.7006704",
"0.68782336",
"0.68782336",
"0.686784",
"0.68645966",
"0.68645966",
"0.6850715",
"0.6848863",
"0.68123287",
"0.6792722",
"0.67743677",
"0.676627... | 0.0 | -1 |
This currently just returns an empty list, as the corresponding Create is not yet implemented | def list_data_cells_filter(self) -> List[Dict[str, Any]]:
return [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create(self, **kwa):\n return []",
"def generate(self):\n return []",
"def create_list(cls, *args):\n return _create_list(cls, *args)",
"def create_list(cls, *args):\n return _create_list(cls, *args)",
"def __noop_list(self, *args, **kwargs):\n return []",
"def list(sel... | [
"0.76777947",
"0.7135053",
"0.7076982",
"0.7076982",
"0.68003124",
"0.6728751",
"0.67102647",
"0.6579876",
"0.6579876",
"0.64027315",
"0.629592",
"0.62576115",
"0.62358373",
"0.62358373",
"0.6229487",
"0.6223494",
"0.6203807",
"0.6203807",
"0.6203807",
"0.6203038",
"0.6199074... | 0.0 | -1 |
Create a new Shop Profile | def create(self, validated_data):
return ShopProfile.objects.create(**validated_data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createProfile(self):\n if self.profile:\n return\n from soc.modules.gsoc.models.profile import GSoCProfile\n user = self.createUser()\n properties = {'link_id': user.link_id, 'student_info': None, 'user': user,\n 'parent': user, 'scope': self.program, 'status': 'active'}\n ... | [
"0.7333698",
"0.7082951",
"0.7064709",
"0.6960642",
"0.6960311",
"0.69601357",
"0.6950246",
"0.68697006",
"0.68697006",
"0.68697006",
"0.6861093",
"0.6851095",
"0.684921",
"0.6847314",
"0.6804711",
"0.6803297",
"0.6714414",
"0.67008674",
"0.6680203",
"0.6668842",
"0.6656584",... | 0.79185814 | 0 |
Update the existing Shop profile | def update(self, instance, validated_data):
instance.shop_name = validated_data.get('shop_name', instance.shop_name)
instance.category = validated_data.get('category', instance.category)
instance.latitude = validated_data.get('latitude', instance.latitude)
instance.longtude = validated_d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_update_profile(self):\n self.cim.update_profile(\n customer_id=u\"222\",\n description=u\"Foo bar baz quz\",\n email=u\"dialtone@gmail.com\",\n customer_profile_id=u\"122\"\n )",
"def update_profile():\n logger.debug(\"entering function update... | [
"0.69551045",
"0.67155063",
"0.6505477",
"0.64532864",
"0.64161766",
"0.63588864",
"0.6357579",
"0.6316166",
"0.63099915",
"0.62903154",
"0.6284435",
"0.6200172",
"0.61856973",
"0.6150992",
"0.6150155",
"0.6134623",
"0.61158746",
"0.60930663",
"0.6086921",
"0.6076155",
"0.606... | 0.5622488 | 57 |
update an existing item | def update(self, instance, validated_data):
instance.item_name = validated_data.get('item_name', instance.item_name)
instance.brand = validated_data.get('brand', instance.brand)
instance.list_price = validated_data.get('list_price', instance.list_price)
instance.uom = validated_data.get(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def updateItem(self, object):\n pass",
"def update_item(self, table, item):",
"def update_item(self, id: str, user: User, **kwargs) -> None:",
"def update_item(id: str, obj: endpoint_model):\n # should this error if exists?\n if obj.id:\n if obj.id != id:\n rais... | [
"0.8280263",
"0.81447977",
"0.7993836",
"0.7355142",
"0.722929",
"0.72020215",
"0.7185629",
"0.7168546",
"0.7024555",
"0.69669366",
"0.6939264",
"0.6877538",
"0.6835842",
"0.6811537",
"0.68082315",
"0.67594725",
"0.6746844",
"0.67179114",
"0.670934",
"0.66849375",
"0.667855",... | 0.6584728 | 28 |
update an existing categories | def update(self, instance, validated_data):
instance.cat_name = validated_data.get('cat_name', instance.cat_name)
instance.img = validated_data.get('img', instance.img)
instance.desc = validated_data.get('desc', instance.desc)
instance.save()
return instance | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, request, *args, **kwargs):\n response = super(CategoryViewSet).update(self, request, *args, *kwargs)\n response.data['message'] = \"Categoria ha sido editada\"",
"def update(self, request, pk=None):\n if not request.auth.user.is_staff:\n return Response(\n ... | [
"0.7418198",
"0.7234741",
"0.72183055",
"0.7139743",
"0.7106988",
"0.69815934",
"0.6827737",
"0.68089455",
"0.67316884",
"0.67297924",
"0.6729216",
"0.67233735",
"0.66815853",
"0.6635296",
"0.6604073",
"0.65747875",
"0.6562277",
"0.65461564",
"0.6542109",
"0.6527648",
"0.6495... | 0.0 | -1 |
Compute the normal vector for each of the given vertexes in the mesh specified by the given vertexes and faces. Each vertex's normal vector is simply the average of the normal vectors of the faces it is adjacent to. | def compute_vertex_normals(vertices_zyx, faces, weight_by_face_area=False, face_normals=None):
if face_normals is None:
face_normals = compute_face_normals_numpy(vertices_zyx, faces, not weight_by_face_area)
# numba is slightly faster for vertex normals, but not face normals
if _numba_available:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculateMeshNormal(mesh_face_vertices):\n mesh_normal = []\n for mesh in mesh_face_vertices:\n v1x = mesh[1, 0] - mesh[0, 0]\n v1y = mesh[1, 1] - mesh[0, 1]\n v1z = mesh[1, 2] - mesh[0, 2]\n v2x = mesh[2, 0] - mesh[1, 0]\n v2y = mesh[2, 1] - mesh[1, 1]\n v2z = m... | [
"0.8153326",
"0.722093",
"0.69128704",
"0.6840134",
"0.6607267",
"0.65231526",
"0.6446641",
"0.64117014",
"0.6319435",
"0.63080317",
"0.6219768",
"0.6148063",
"0.6132507",
"0.61289865",
"0.6120251",
"0.6085422",
"0.60112137",
"0.6003639",
"0.59615904",
"0.5959277",
"0.5946175... | 0.6507983 | 6 |
Compute the normal vector for the given triangular faces. The faces are specified in the typical fashion, i.e. each face's corners are specified as a list of 3 indices, indicating which vertices in the given vertex list comprise the face corners. If normalize=True, then unit vectors are returned. Otherwise, the magnitu... | def compute_face_normals(vertices_zyx, faces, normalize=False):
# numpy is faster than numba for face normals.
# Always use numpy.
return compute_face_normals_numpy(vertices_zyx, faces, normalize) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculateMeshNormal(mesh_face_vertices):\n mesh_normal = []\n for mesh in mesh_face_vertices:\n v1x = mesh[1, 0] - mesh[0, 0]\n v1y = mesh[1, 1] - mesh[0, 1]\n v1z = mesh[1, 2] - mesh[0, 2]\n v2x = mesh[2, 0] - mesh[1, 0]\n v2y = mesh[2, 1] - mesh[1, 1]\n v2z = m... | [
"0.7125069",
"0.71220785",
"0.68017197",
"0.6713881",
"0.6648629",
"0.66387725",
"0.66331315",
"0.66081",
"0.6550402",
"0.65357506",
"0.64759254",
"0.646564",
"0.6436271",
"0.6376584",
"0.6371165",
"0.6355018",
"0.6310866",
"0.62548745",
"0.61315584",
"0.6108793",
"0.6099856"... | 0.67967165 | 3 |
numba doesn't support np.cross() outofthebox, so here it is. | def cross(u,v):
u1, u2, u3 = u
v1, v2, v3 = v
return np.array([u2*v3 - u3*v2,
u3*v1 - u1*v3,
u1*v2 - u2*v1], dtype=u.dtype) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cross(a, b):\n #return np.cross(a,b)\n\n return vector(a[1] * b[2] - a[2] * b[1],\n a[2] * b[0] - a[0] * b[2],\n a[0] * b[1] - a[1] * b[0])",
"def cross(a, b):\n return np.array([a[1]*b[2] - a[2]*b[1],\n a[2]*b[0] - a[0]*b[2],\n ... | [
"0.6968073",
"0.6852077",
"0.66056025",
"0.6594874",
"0.65571004",
"0.6494983",
"0.63625574",
"0.631185",
"0.6259538",
"0.61961305",
"0.6146926",
"0.6109132",
"0.6079648",
"0.59982544",
"0.5980006",
"0.59572953",
"0.5877286",
"0.57682353",
"0.57618666",
"0.5736346",
"0.573094... | 0.5799124 | 17 |
Same as np.linalg.norm for a singlevector input. By avoiding np.linalg.norm, we can support running on numpy installs that were not compiled with BLAS. (Admittedly, that's a rare scenario.) | def norm_l2(v):
return np.sqrt((v**2).sum()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def norm(vec):\n return np.linalg.norm(vec)",
"def fast_norm(x):\n return sqrt(dot(x, x.T))",
"def l1(vec):\n return np.linalg.norm(vec, ord=1)",
"def vector_norm(data, axis=None, out=None):\n data = np.array(data, dtype=np.float64, copy=True)\n if out is None:\n if data.ndim == 1:\n ... | [
"0.8028968",
"0.78174204",
"0.7628523",
"0.7624475",
"0.75862074",
"0.7564668",
"0.75592655",
"0.75401086",
"0.74093753",
"0.7405673",
"0.73849475",
"0.73453254",
"0.73112965",
"0.72778994",
"0.7238737",
"0.72353673",
"0.7212942",
"0.7209183",
"0.7182525",
"0.717279",
"0.7167... | 0.6561202 | 70 |
Creates the default regression submodel. Args | def create_classification_graf(
inputs,
num_classes,
pyramid_feature_size=256,
classification_feature_size=256,
name='classification_submodel'
):
options = {
'kernel_size': 3,
'strides': 1,
'padding': 'same',
}
outputs = inputs
for i in ran... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_regression_submodels(input_shape, option, regression_feature_size=256, FC_num_of_nuerons=1024, name='regression_submodel'):\n if option == 1 or option == 0:\n inputs = keras.layers.Input(shape=(None, None, input_shape))\n # All new conv layers are initialized\n # with bias b = 0 ... | [
"0.70448923",
"0.6608687",
"0.64323825",
"0.6384243",
"0.6340081",
"0.63179123",
"0.6266902",
"0.6041894",
"0.6030131",
"0.60073376",
"0.59656024",
"0.5949215",
"0.5946567",
"0.5942358",
"0.5942143",
"0.5932648",
"0.59324545",
"0.5924777",
"0.5908567",
"0.5888867",
"0.5877790... | 0.0 | -1 |
Creates the default regression submodel. Args | def create_regression_submodels(input_shape, option, regression_feature_size=256, FC_num_of_nuerons=1024, name='regression_submodel'):
if option == 1 or option == 0:
inputs = keras.layers.Input(shape=(None, None, input_shape))
# All new conv layers are initialized
# with bias b = 0 and a Gau... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def default_regression_model(num_values, num_anchors, pyramid_feature_size=256, regression_feature_size=256, name='regression_submodel'):\n # All new conv layers except the final one in the\n # RetinaNet (classification) subnets are initialized\n # with bias b = 0 and a Gaussian weight fill with stddev = ... | [
"0.6608687",
"0.64323825",
"0.6384243",
"0.6340081",
"0.63179123",
"0.6266902",
"0.6041894",
"0.6030131",
"0.60073376",
"0.59656024",
"0.5949215",
"0.5946567",
"0.5942358",
"0.5942143",
"0.5932648",
"0.59324545",
"0.5924777",
"0.5908567",
"0.5888867",
"0.58777905",
"0.5841634... | 0.70448923 | 0 |
Creates the FPN layers on top of the backbone features. Args | def create_pyramid_features(C3, C4, C5, feature_size=256):
# upsample C5 to get P5 from the FPN paper
P5 = keras.layers.Conv2D(feature_size, kernel_size=1, strides=1, padding='same', name='C5_reduced')(C5)
P5_upsampled = layers.UpsampleLike(name='P5_upsampled')([P5, C4])
P5 = keras.l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_feature_layers(self, config):\n raise NotImplementedError",
"def setup_layers(self):\n if self.args.model == \"exact\":\n self.layer = PPNPLayer\n else:\n self.layer = APPNPLayer\n self.setup_layer_structure()",
"def build_layers(self):\n raise NotI... | [
"0.7184961",
"0.6859367",
"0.68180364",
"0.6733854",
"0.62066865",
"0.6180018",
"0.6080448",
"0.6045887",
"0.60403764",
"0.60108316",
"0.59789175",
"0.59536123",
"0.5932654",
"0.5929342",
"0.5917331",
"0.59011847",
"0.5870025",
"0.5858796",
"0.585748",
"0.58048093",
"0.579233... | 0.0 | -1 |
Creates the FPN layers on top of the backbone features. Args | def create_p3_feature(C3, C4, C5, feature_size=256):
P5 = keras.layers.Conv2D(feature_size, kernel_size=1, strides=1, padding='same', name='C5_reduced')(C5)
P5_upsampled = layers.UpsampleLike(name='P5_upsampled')([P5, C4])
# add P5 elementwise to C4
P4 = keras.layers.Conv2D(feature_size, kernel_size=1,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_feature_layers(self, config):\n raise NotImplementedError",
"def setup_layers(self):\n if self.args.model == \"exact\":\n self.layer = PPNPLayer\n else:\n self.layer = APPNPLayer\n self.setup_layer_structure()",
"def build_layers(self):\n raise NotI... | [
"0.7185184",
"0.6858193",
"0.6816799",
"0.67348593",
"0.6205501",
"0.6178274",
"0.6080039",
"0.6045217",
"0.6040359",
"0.6010081",
"0.59792393",
"0.5952754",
"0.59325486",
"0.5928713",
"0.59169686",
"0.59022444",
"0.58678496",
"0.58580995",
"0.58571285",
"0.58048695",
"0.5791... | 0.0 | -1 |
Construct a RetinaNet model on top of a backbone. This model is the minimum model necessary for training (with the unfortunate exception of anchors as output). Args | def gyf_net(
inputs,
backbone_layers,
num_classes,
option = 1,
do_dropout = False,
nd_weights=[ 0, 0, 0.01 , 0.01] ,
wd_weights=[ 0, 0, 0.01, 0.01],
name='gyf_net',
FC_num_of_nuerons = 128
):
dropout_param = 0.5
C3, C4, C5 = backbone_layer... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_backbone(config):\n assert config.MODEL.BACKBONE in ['resnet50', 'resnet101'], \"backbone name is not supported!\"\n backbone_name = config.MODEL.BACKBONE\n dilation = False\n train_backbone = not config.EVAL\n return_interm_layers = False #TODO: impl case True for segmentation\n\n posi... | [
"0.6656871",
"0.64971143",
"0.647989",
"0.6461896",
"0.6445523",
"0.6351768",
"0.6273475",
"0.6227288",
"0.6215876",
"0.6215043",
"0.6200588",
"0.61176455",
"0.6098872",
"0.6095074",
"0.6092274",
"0.60904074",
"0.60895133",
"0.6086633",
"0.608019",
"0.6066834",
"0.6055574",
... | 0.0 | -1 |
Construct a RetinaNet model on top of a backbone and adds convenience functions to output boxes directly. This model uses the minimum retinanet model and appends a few layers to compute boxes within the graph. These layers include applying the regression values to the anchors and performing NMS. Args | def gyf_net_LCC(
model=None,
option = 'reg_fpn_p3_p7_mle',
name='gyf_net-LCC',
**kwargs
):
if model is None:
model = gyf_net(**kwargs)
# we expect the anchors, regression and classification values as first output
# todo - remove nd option
if option == 'reg_baseli... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def retinanet_bbox(model= None, applyNms= True, class_specific_filter= True, name='retinanet-bbox', anchor_params= None, **kwargs):\n\n # if no anchor parameters are passed, use default values\n if anchor_params is None:\n anchor_params = AnchorParameters_default\n\n # create RetinaNet model\n i... | [
"0.64139163",
"0.5904596",
"0.5881505",
"0.58185",
"0.57925415",
"0.5775857",
"0.5696076",
"0.5665686",
"0.5630072",
"0.56215036",
"0.5606611",
"0.5603881",
"0.5564644",
"0.5499803",
"0.5498145",
"0.5479341",
"0.5479254",
"0.54608303",
"0.5448227",
"0.5445161",
"0.5440332",
... | 0.0 | -1 |
Get commandline arguments and return in a dictionary. | def GetArgs():
UserArgs = {}
UserArgs['help'] = False
UserArgs['RsodFileName'] = ""
UserArgs['BiosPathX64'] = ""
for i in range(1,len(sys.argv)):
if sys.argv[i].lower() == "-help" : UserArgs["help"] = True
elif sys.argv[i].lower() == "-h" : UserArgs["he... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def retrieve_args_dict():\n process_args = sys.argv[1:]\n dictionary = dict()\n for process_arg in process_args:\n splitted = process_arg.split(\":\")\n if len(splitted) > 1:\n key = splitted[0]\n value = \"\".join(splitted[1:])\n dictionary[key] = value\n ... | [
"0.8392568",
"0.73264146",
"0.72220016",
"0.7195668",
"0.7151639",
"0.71046627",
"0.7067025",
"0.7011563",
"0.70049137",
"0.6917291",
"0.691006",
"0.689744",
"0.6896975",
"0.68951774",
"0.68362814",
"0.68124163",
"0.68043065",
"0.67980427",
"0.6727538",
"0.6687054",
"0.668665... | 0.7052927 | 7 |
This function plots various quantities output from surveySim. | def plotsurvey(filename='obslist_all.fits', plot_type='f', program='m'):
t = Table.read(filename, format='fits')
if plot_type == 'f':
fig, ax = plt.subplots()
ra = t['RA']
ra[ra>300.0] -= 360.0
dec = t['DEC']
mjd = t['MJD']
mjd_start = np.min(mjd)
mjd -... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot(self):\n\t\tself.plotOfSpect()",
"def plot(self):\n\t\tself.plotOfSpect().plot()",
"def plot_q_values(self):\n\n sim_freq = self.conf['Simulation']['params']['frequency']\n sim_wvlgth = 1e9*consts.c / sim_freq\n leg_str = ''\n for mat, matpath in self.conf['Materials'].item... | [
"0.6960224",
"0.6864004",
"0.6802096",
"0.6696738",
"0.66458255",
"0.6615099",
"0.66061896",
"0.64792323",
"0.647615",
"0.6462577",
"0.6423786",
"0.6413281",
"0.6410296",
"0.6405238",
"0.6347649",
"0.6342669",
"0.6320201",
"0.6292734",
"0.62917215",
"0.6290562",
"0.6255119",
... | 0.6101525 | 32 |
get system network disk mount points | def get_mount_points():
points = []
t = subprocess.check_output(['mount'])
t = t.decode()
for line in t.splitlines():
t = line.find('smbfs')
if t < 0: continue
b = line.find(' on ')
points.append(line[b+4: t-2])
# //share@win10.shared/storage on /Volumes/storage... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mpt():\n lbl_drives = ['device','mountpoint','fstype']\n disks = [d[0:3] for d in psutil.disk_partitions()]\n drives = [dict(zip(lbl_drives,ds)) for ds in disks]\n return [d['mountpoint']for d in drives]",
"def get_disks(self):\n result = {}\n\n exp = self.config['devices']\n ... | [
"0.68773633",
"0.68158823",
"0.67882913",
"0.6774222",
"0.66594845",
"0.66355723",
"0.6554326",
"0.64806867",
"0.6475302",
"0.6474165",
"0.64323974",
"0.63421154",
"0.62973434",
"0.6283676",
"0.625942",
"0.62251365",
"0.6212416",
"0.6192075",
"0.61354935",
"0.613342",
"0.6131... | 0.78018576 | 0 |
Create a VOEvent receiver service. The receiver service accepts VOEvent messages submitted to the broker by authors. | def makeBroadcasterService(endpoint, local_ivo, test_interval, whitelist):
factory = VOEventBroadcasterFactory(local_ivo, test_interval)
if log.LEVEL >= log.Levels.INFO:
factory.noisy = False
whitelisting_factory = WhitelistingFactory(factory, whitelist, "subscription")
if log.LEVEL >= log.Leve... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_event(self):\n\t\treturn handle_to_object(call_sdk_function('PrlVm_CreateEvent', self.handle))",
"def make_service_offer(self, incoming: Demand):\n rospy.loginfo(\"Making service offer...\")\n\n offer = Offer()\n offer.model = Multihash(rospy.get_param(\"~model\"))\n offer.... | [
"0.5781585",
"0.5657519",
"0.56021494",
"0.55497426",
"0.55497426",
"0.55497426",
"0.54814553",
"0.5467501",
"0.5458404",
"0.541941",
"0.5413253",
"0.5380272",
"0.5364278",
"0.53538424",
"0.5344692",
"0.53310215",
"0.52988505",
"0.5298473",
"0.5285878",
"0.5276575",
"0.527268... | 0.62264496 | 0 |
Test whether number of generated exemplars corresponds to expected number +/ tolerance | def test_num_of_exemplars(target_exemplars, tol):
df = h2o.create_frame(
rows=10000,
cols=2,
categorical_fraction=0.1,
integer_fraction=0.3,
real_range=100,
seed=1234
)
agg = H2OAggregatorEstimator(target_num_exemplars=target_exemplars, rel_tol_num_exemplars=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_amount_in_tons(self):",
"def test_excess_quantity(self):\n excess = self._uncertain_demand.excess_stock\n avg_order = sum([int(item) for item in self._data_set.values()]) //len(self._data_set)\n variance = [(item - avg_order) for item in self._data_set.values()]\n stdev = pow... | [
"0.62417066",
"0.6170665",
"0.61069566",
"0.6106596",
"0.6075478",
"0.60676223",
"0.59904754",
"0.59904754",
"0.5966602",
"0.59636664",
"0.5913543",
"0.5900503",
"0.5890577",
"0.5879676",
"0.5875304",
"0.58695227",
"0.58620834",
"0.58284837",
"0.5817856",
"0.58031934",
"0.579... | 0.6148227 | 2 |
To catch the old API structure in which creating the parser would immediately parse and return data. | def __new__(cls, data=None,
customization=None,
ignore_nonstandard_types=True,
homogenise_fields=True):
if data is None:
return super(BibTexParser, cls).__new__(cls)
else:
# For backwards compatibility: if data is given, parse and ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse(self):\n pass",
"def parse(self):\n pass",
"def parse(self):\n pass",
"def parse(self):\n pass",
"def parse(self):\n pass",
"def parse(self):\n raise NotImplementedError",
"def parse(self):",
"def parse_api(self, soup):\n return {}",
"def ... | [
"0.7138232",
"0.69025296",
"0.69025296",
"0.69025296",
"0.69025296",
"0.67519003",
"0.67396116",
"0.66833234",
"0.6609541",
"0.6606015",
"0.6590835",
"0.6550816",
"0.6404248",
"0.6295026",
"0.62539226",
"0.6238733",
"0.6234285",
"0.6176463",
"0.59207684",
"0.59207684",
"0.590... | 0.0 | -1 |
Creates a parser for rading BibTeX files | def __init__(self):
self.bib_database = BibDatabase()
#: Callback function to process BibTeX entries after parsing, for example to create a list from a string with
#: multiple values. By default all BibTeX values are treated as simple strings. Default: `None`.
self.customization = None
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_bib_from_bibtex(filename):\n\tentry_regex = r'''\n\t\t\t(?msx) # flags: multi-line, dot-match-all, verbose\n\t\t\t^@\\w+\\{ # start of line, item type\n\t\t\t.*? # content, can span multiple lines, non-greedy\n\t\t\t^\\} # start of line, closing parens\n\t\t\t'''\n\tattr_regex = r'''\n\t... | [
"0.6234612",
"0.6147995",
"0.60319656",
"0.59629756",
"0.5920162",
"0.5742437",
"0.5685837",
"0.55988944",
"0.5565244",
"0.55591327",
"0.5548441",
"0.55469084",
"0.5477194",
"0.542481",
"0.54220295",
"0.53916395",
"0.5366751",
"0.53573483",
"0.53022027",
"0.52594346",
"0.5246... | 0.60859346 | 2 |
Parse a BibTeX string into an object | def parse(self, bibtex_str):
self.bibtex_file_obj = self._bibtex_file_obj(bibtex_str)
self._parse_records(customization=self.customization)
return self.bib_database | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bibtex_to_dict(bibtex):\n global logger\n result = dict()\n if os.path.exists(bibtex):\n fd = open(bibtex, \"r\")\n logger.debug(\"Reading in file %s\" % bibtex)\n text = fd.read()\n else:\n text = bibtex\n logger.debug(\"Removing comments...\")\n text = re.sub(r\"... | [
"0.66628987",
"0.6659649",
"0.633736",
"0.633628",
"0.6253365",
"0.6071626",
"0.5941959",
"0.59201235",
"0.5868278",
"0.5813296",
"0.57727057",
"0.57572824",
"0.5704655",
"0.5671336",
"0.562297",
"0.5534481",
"0.5516728",
"0.54690385",
"0.5426646",
"0.5413599",
"0.5386806",
... | 0.6913478 | 0 |
Parse a BibTeX file into an object | def parse_file(self, file):
return self.parse(file.read()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_bib_from_bibtex(filename):\n\tentry_regex = r'''\n\t\t\t(?msx) # flags: multi-line, dot-match-all, verbose\n\t\t\t^@\\w+\\{ # start of line, item type\n\t\t\t.*? # content, can span multiple lines, non-greedy\n\t\t\t^\\} # start of line, closing parens\n\t\t\t'''\n\tattr_regex = r'''\n\t... | [
"0.7056748",
"0.6789347",
"0.65760547",
"0.6506177",
"0.6466266",
"0.62614244",
"0.61830676",
"0.6071847",
"0.59961665",
"0.5936106",
"0.58459806",
"0.58455586",
"0.574384",
"0.56954813",
"0.56943685",
"0.5688495",
"0.56305325",
"0.5595255",
"0.55480367",
"0.5541105",
"0.5505... | 0.5276055 | 36 |
Parse the bibtex into a list of records. | def _parse_records(self, customization=None):
def _add_parsed_record(record, records):
"""
Atomic function to parse a record
and append the result in records
"""
if record != "":
logger.debug('The record is not empty. Let\'s parse it.')... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse(self, bibtex_str):\n self.bibtex_file_obj = self._bibtex_file_obj(bibtex_str)\n self._parse_records(customization=self.customization)\n return self.bib_database",
"def parse_bib(filename, entry_regex, parse_func):\n\twith open(filename) as f:\n\t\treturn filter(None, (parse_func(it... | [
"0.7069204",
"0.66858053",
"0.6365787",
"0.6218454",
"0.61647767",
"0.6109565",
"0.605119",
"0.60247535",
"0.59034073",
"0.5703395",
"0.56781554",
"0.56023383",
"0.5566754",
"0.55462235",
"0.55357593",
"0.5528895",
"0.5505986",
"0.54787135",
"0.54554504",
"0.5440011",
"0.5430... | 0.72426885 | 0 |
Atomic function to parse a record and append the result in records | def _add_parsed_record(record, records):
if record != "":
logger.debug('The record is not empty. Let\'s parse it.')
parsed = self._parse_record(record, customization=customization)
if parsed:
logger.debug('Store the result of the parsed rec... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_record(self, record):\n raise NotImplementedError()",
"def parse_record(dom, record_dict, log):\n return parser(dom, record_dict, log)",
"def _parse_records(self, customization=None):\n def _add_parsed_record(record, records):\n \"\"\"\n Atomic function to parse... | [
"0.6970799",
"0.6505174",
"0.63539755",
"0.62376463",
"0.6231728",
"0.6189907",
"0.6178221",
"0.6087885",
"0.5943535",
"0.59019214",
"0.5897599",
"0.5895698",
"0.5873401",
"0.58263826",
"0.5749148",
"0.57163817",
"0.57113546",
"0.570671",
"0.5662196",
"0.56533664",
"0.5653366... | 0.7449858 | 0 |
Parse a record. tidy whitespace and other rubbish parse out the bibtype and citekey find all the keyvalue pairs it contains | def _parse_record(self, record, customization=None):
d = {}
if not record.startswith('@'):
logger.debug('The record does not start with @. Return empty dict.')
return {}
# if a comment record, add to bib_database.comments
if record.lower().startswith('@comment')... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_record(self, record):\n raise NotImplementedError()",
"def parse_record(self, in_rec):\n \n geo_util = geo.Geo()\n \n self.metadata = {}\n for k, v in in_rec.items():\n if k == 'metadata2': continue\n elif k == 'geometry':\n ... | [
"0.6419528",
"0.63260657",
"0.61760867",
"0.6131838",
"0.6122296",
"0.6120553",
"0.5983646",
"0.58799636",
"0.58595246",
"0.5855788",
"0.584823",
"0.58271646",
"0.58078647",
"0.57758385",
"0.57636255",
"0.5644182",
"0.5610186",
"0.5606317",
"0.55948454",
"0.55234295",
"0.5517... | 0.72723114 | 0 |
Strip double quotes enclosing string | def _strip_quotes(self, val):
logger.debug('Strip quotes')
val = val.strip()
if val.startswith('"') and val.endswith('"'):
return val[1:-1]
return val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _Unquote(s):\n if not hasattr(s, 'strip'):\n return s\n # Repeated to handle both \"'foo'\" and '\"foo\"'\n return s.strip(\"\\\"'\")",
"def _Unquote(s):\n if not hasattr(s, 'strip'):\n return s\n # Repeated to handle both \"'foo'\" and '\"foo\"'\n return s.strip(\"'\").strip('\"').strip(\"'\")",... | [
"0.77753305",
"0.77129984",
"0.7416668",
"0.7369961",
"0.7316195",
"0.72749907",
"0.727079",
"0.72586817",
"0.7171268",
"0.7170626",
"0.7048465",
"0.7045705",
"0.6996785",
"0.68673736",
"0.6739336",
"0.6514188",
"0.64913297",
"0.64645445",
"0.643386",
"0.64072984",
"0.6398886... | 0.73426867 | 4 |
Strip braces enclosing string | def _strip_braces(self, val):
logger.debug('Strip braces')
val = val.strip()
if val.startswith('{') and val.endswith('}') and self._full_span(val):
return val[1:-1]
return val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_stray_braces(self, tex):\n num_lefts, num_rights = [\n tex.count(char)\n for char in \"{}\"\n ]\n if num_rights > num_lefts:\n backwards = tex[::-1].replace(\"}\", \"\", num_rights - num_lefts)\n tex = backwards[::-1]\n elif num_lef... | [
"0.7257907",
"0.6704662",
"0.663527",
"0.663437",
"0.65309894",
"0.65099",
"0.6454627",
"0.63949865",
"0.6302393",
"0.6281844",
"0.62191236",
"0.62042516",
"0.6161475",
"0.60913813",
"0.60668725",
"0.6063109",
"0.5937413",
"0.59302425",
"0.58825225",
"0.58386445",
"0.58217025... | 0.76519185 | 0 |
Substitute string definitions inside larger expressions | def _string_subst_partial(self, val):
def repl(m):
k = m.group('id')
replacement = self.bib_database.strings[k.lower()] if k.lower() in self.bib_database.strings else k
pre = '"' if m.group('pre') != '"' else ''
post = '"' if m.group('post') != '"' else ''
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __Subst(self, m, s, l):\n if s is None:\n s = ''\n #if type(s) is types.LongType:\n #1.5.2: s = str(s)[:-1]\n return self.regexp.Subst(l, DTL.TemplateRegExp.macros[m], str(s))",
"def test_evaluate_replace_expression(self):\n value = self.evaluate_common(\"rep... | [
"0.6560497",
"0.6532088",
"0.64842784",
"0.64777434",
"0.62473774",
"0.622621",
"0.622045",
"0.6183432",
"0.6173008",
"0.6143813",
"0.61242",
"0.6123574",
"0.6107318",
"0.6066054",
"0.6050567",
"0.6044567",
"0.6040717",
"0.6009045",
"0.6002451",
"0.59890664",
"0.5989054",
"... | 0.7003312 | 0 |
Clean instring before adding to dictionary | def _add_val(self, val):
if not val or val == "{}":
return ''
val = self._strip_braces(val)
val = self._strip_quotes(val)
val = self._strip_braces(val)
val = self._string_subst(val)
return val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sanitize(self, _input):\n sanitized = {}\n for key, inp in _input.items():\n try:\n key = html.escape(key).strip()\n except AttributeError:\n pass\n # try:\n # inp = html.escape(inp).strip()\n # except (Attri... | [
"0.6268545",
"0.62286484",
"0.6139651",
"0.61188745",
"0.6037264",
"0.5991762",
"0.5991364",
"0.5975864",
"0.5972714",
"0.592272",
"0.5904946",
"0.58103925",
"0.580904",
"0.5787211",
"0.5737508",
"0.5736629",
"0.5727791",
"0.57251036",
"0.56657696",
"0.5640273",
"0.56325823",... | 0.0 | -1 |
Add a key and homogeneize alternative forms. | def _add_key(self, key):
key = key.strip().strip('@').lower()
if self.homogenise_fields:
if key in list(self.alt_dict.keys()):
key = self.alt_dict[key]
if not isinstance(key, ustr):
return ustr(key, 'utf-8')
else:
return key | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_key(mu_key):\n params['key'] = mu_key",
"def add_key(self, key_list: list) -> None:\n\n for key, funct, desc in key_list:\n # Force keys to be lowercase\n key = key.lower()\n \n self.key_functs[key] = funct\n self.key_satified[key] = False\... | [
"0.6486366",
"0.6354456",
"0.6322555",
"0.61398035",
"0.605703",
"0.60256815",
"0.59840685",
"0.5979315",
"0.5956355",
"0.5809993",
"0.5785336",
"0.5777266",
"0.57652295",
"0.57652295",
"0.5716468",
"0.56604296",
"0.56133515",
"0.558195",
"0.55463797",
"0.5544744",
"0.5540097... | 0.5817976 | 9 |
Sets the access token. | def set_access_token(self, value: str) -> None:
self.__requester.set_authorization(value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_access_token(self, access_token):\n self.access_token = access_token",
"def access_token(self, access_token):\n\n self._access_token = access_token",
"def set_access_token(self, token):\n\n self.__current_request_mock.headers['Authorization'] = token",
"def set_access_token(self,... | [
"0.8726035",
"0.8284945",
"0.78996503",
"0.75930804",
"0.7460136",
"0.7379208",
"0.7260947",
"0.71620584",
"0.7155994",
"0.70417875",
"0.70335436",
"0.6937926",
"0.6937383",
"0.6926173",
"0.67172366",
"0.66388446",
"0.6613158",
"0.6582777",
"0.64298064",
"0.637697",
"0.634287... | 0.8179823 | 2 |
Provides the currently set access point. | def get_access_point(self) -> str:
return self.__requester.base_url | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def access(self):\n return self._access",
"def access(self):\n return self._access",
"def access_point_id(self) -> str:\n return pulumi.get(self, \"access_point_id\")",
"def _getCurrentPoint(self):\n return self.__currentPoint",
"def get_fan_set_point(self):\n return self... | [
"0.6743609",
"0.6743609",
"0.6608858",
"0.65723866",
"0.6504079",
"0.6337296",
"0.622661",
"0.622661",
"0.6189821",
"0.6098333",
"0.60944",
"0.60067403",
"0.5992989",
"0.59382397",
"0.588125",
"0.5860819",
"0.5853144",
"0.5789034",
"0.57688814",
"0.5752235",
"0.5752235",
"0... | 0.66070384 | 3 |
Sets the access point to communicate with. | def set_access_point(self, value: str) -> None:
self.__requester.set_base_url(value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setSetpoint(self, point):\n\n\t\tself._setpoint = point",
"def setPoint(self, point):\n self.point = point",
"def setpointCallback(self,setpoint):\n if not self.setpoint_valid:\n rospy.loginfo(\"First setpoint received.\")\n self.setpoint_valid = True\n self.set_p... | [
"0.6390105",
"0.62136114",
"0.6117438",
"0.5991195",
"0.5894934",
"0.5868396",
"0.5854952",
"0.58540964",
"0.58540964",
"0.58540964",
"0.5821169",
"0.5821169",
"0.580778",
"0.58021396",
"0.5796809",
"0.579131",
"0.57864845",
"0.5778461",
"0.57453096",
"0.5659611",
"0.5646041"... | 0.68554735 | 0 |
Provides the list of all active builds. | def get_active_from_github_id(
self, github_id: Union[str, int], *, params: Optional[dict] = None
) -> "resource_types.Active":
return communicator.Active(self.__requester).from_github_id(
github_id=int(github_id), parameters=params
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Builds():\n return builds",
"def builds(self):\n return self._builds",
"def getBuilds():",
"def getCurrentBuilds():\n # again, we could probably provide an object for 'waiting' and\n # 'interlocked' too, but things like the Change list might still be\n # subject to change",... | [
"0.76474434",
"0.74677944",
"0.72095585",
"0.70357376",
"0.7003857",
"0.68523914",
"0.68523914",
"0.67825145",
"0.66561615",
"0.650555",
"0.6467641",
"0.6301073",
"0.6226253",
"0.61929137",
"0.6023285",
"0.59893006",
"0.5980562",
"0.5972008",
"0.59683216",
"0.59568816",
"0.59... | 0.0 | -1 |
Provides the list of all active builds for the given login in the given provider. | def get_active_from_login(
self, login: str, *, provider: str = "github", params: Optional[dict] = None
) -> "resource_types.Active":
return communicator.Active(self.__requester).from_login(
login=login, provider=provider, parameters=params
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Builds():\n return builds",
"def get_builds(self, *, params: Optional[dict] = None) -> \"resource_types.Builds\":\n\n return communicator.Builds(self.__requester).fetch(parameters=params)",
"def build_list(ctx, show_url, show_data,\n start, count,\n project, build_type... | [
"0.5595932",
"0.5579669",
"0.5575324",
"0.5530652",
"0.55290043",
"0.5472273",
"0.5448642",
"0.5247109",
"0.5247109",
"0.52199453",
"0.5217522",
"0.51758015",
"0.5152291",
"0.50583714",
"0.50256395",
"0.49641752",
"0.4945307",
"0.48910722",
"0.4876092",
"0.486524",
"0.4823432... | 0.5465332 | 6 |
Provides the list of broadcasts of the current user. | def get_broadcasts(
self, *, params: Optional[dict] = None
) -> "resource_types.Broadcasts":
return communicator.Broadcasts(self.__requester).fetch(parameters=params) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list( self, mess, args):\n user = self.get_sender_username(mess)\n args = args.replace(' ', '_')\n if user in self.users:\n user_list = 'All these users are subscribed - \\n'\n user_list += '\\n'.join(['%s :: %s' %(u, self.users[u]) for u in sorted(self.users)])\n ... | [
"0.60016054",
"0.5881634",
"0.5803563",
"0.57533914",
"0.5750388",
"0.57274336",
"0.56940734",
"0.5687119",
"0.56761175",
"0.564202",
"0.5639454",
"0.56097776",
"0.56062895",
"0.55889046",
"0.5585895",
"0.5524598",
"0.55238736",
"0.55003995",
"0.5479891",
"0.5464656",
"0.5459... | 0.6519794 | 0 |
Provides the build information from its ID. | def get_build(
self, build_id: Union[int, str], *, params: Optional[dict] = None
) -> "resource_types.Build":
return communicator.Build(self.__requester).from_id(
build_id=build_id, parameters=params
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_build(self, build_id):\n pass",
"def build():\n return get_cached(\"build.json\", False).get(\"build_id\")",
"def build_id(self):\n if self.method == 'tagBuild':\n return self.params[1]",
"def build_info(self):\n return self._build_info",
"def get_koji_build_info(... | [
"0.77781296",
"0.7655416",
"0.6897013",
"0.68396556",
"0.672192",
"0.66944796",
"0.66136545",
"0.6557567",
"0.64643776",
"0.6447651",
"0.6428573",
"0.6414766",
"0.6414766",
"0.64105403",
"0.6359696",
"0.62531394",
"0.6200882",
"0.6199",
"0.6077942",
"0.60720354",
"0.5994919",... | 0.66666526 | 6 |
Provides the list of builds of the current user. | def get_builds(self, *, params: Optional[dict] = None) -> "resource_types.Builds":
return communicator.Builds(self.__requester).fetch(parameters=params) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Builds():\n return builds",
"def getBuilds():",
"def build_list(ctx, show_url, show_data,\n start, count,\n project, build_type_id, branch, status, running, tags, user,\n output_format, columns):\n kwargs = {'start': start,\n 'count': count}\n ... | [
"0.6883745",
"0.6575796",
"0.6572598",
"0.64355004",
"0.6207138",
"0.61170244",
"0.60926265",
"0.60643363",
"0.59929526",
"0.5961092",
"0.5896418",
"0.5896418",
"0.5819128",
"0.57775116",
"0.57336736",
"0.5678688",
"0.5565604",
"0.5452168",
"0.544499",
"0.5438009",
"0.5406519... | 0.6142329 | 5 |
Provides a cron from its given ID. | def get_cron(
self, cron_id: Union[str, int], *, params: Optional[dict] = None
) -> "resource_types.Cron":
return communicator.Cron(self.__requester).from_id(
cron_id=cron_id, parameters=params
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cron_id(self, cr, uid, context):\n cron_obj = self.pool.get('ir.cron')\n # find the cron that send messages\n cron_id = cron_obj.search(cr, uid, [('function', 'ilike', self.cron['function']),\n ('model', 'ilike', self.cron['model'])],\n ... | [
"0.65078187",
"0.6431072",
"0.6326919",
"0.6021894",
"0.600872",
"0.5984055",
"0.58517635",
"0.5767667",
"0.5746677",
"0.5657153",
"0.55429775",
"0.5541055",
"0.5533714",
"0.55243057",
"0.55132204",
"0.5493868",
"0.5479761",
"0.54725164",
"0.54444087",
"0.5411881",
"0.5393716... | 0.8255051 | 0 |
Provides a job from its given ID. | def get_job(
self, job_id: Union[str, int], *, params: Optional[dict] = None
) -> "resource_types.Job":
return communicator.Job(self.__requester).from_id(
job_id=job_id, parameters=params
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_job(self, _id):\n data = {\n 'class': 'Job',\n 'id': _id,\n 'attrs': {},\n }\n job = self.db_client.send_request('list', json.dumps(data))\n\n return Job(\n _id=job['id'],\n _type=job['type'],\n task=job['task'],\... | [
"0.8370322",
"0.81394696",
"0.78803784",
"0.77068985",
"0.76749647",
"0.76451606",
"0.75760686",
"0.75058204",
"0.74840623",
"0.7439674",
"0.7318414",
"0.7263681",
"0.7233894",
"0.71796244",
"0.7149467",
"0.71003586",
"0.70752484",
"0.7072272",
"0.7063138",
"0.70405346",
"0.6... | 0.8248076 | 1 |
Provides the list of jobs of the current user. | def get_jobs(self, *, params: Optional[dict] = None) -> "resource_types.Jobs":
return communicator.Jobs(self.__requester).fetch(parameters=params) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_job_list(self):\n return self.job_list",
"def get_job_list(self):\n return self.job_list",
"def list_jobs(self):\n\n return dict(self._from_json(self.manage.run(override=\"list-jobs\")))",
"def list_jobs(user_data, cache):\n user = cache.ensure_user(user_data)\n\n jobs = []... | [
"0.7658048",
"0.7658048",
"0.7589254",
"0.7546226",
"0.75082177",
"0.73086214",
"0.7287166",
"0.72396624",
"0.7215694",
"0.720352",
"0.7182318",
"0.714295",
"0.71399367",
"0.71126217",
"0.7103244",
"0.7100594",
"0.7039654",
"0.6998702",
"0.69447064",
"0.6885839",
"0.6881713",... | 0.6554408 | 43 |
Lints the given subject. | def lint(self, subject: Union[TextIOWrapper, bytes, str]) -> "resource_types.Lint":
if isinstance(subject, TextIOWrapper):
data = subject.read()
elif isinstance(subject, (str, bytes)):
data = subject
else:
raise TypeError(
f"<subject> must be ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def change_subject(self, new_subject):\n raise NotImplementedError",
"def lint(self, vartok, linted_entry):\n raise NotImplemented",
"def update(self, subject: Subject) -> None:\n pass",
"def update(self, subject: Subject) -> None:\n pass",
"def lint(ctx):\r\n print('Running ... | [
"0.54728234",
"0.5425725",
"0.54179674",
"0.54179674",
"0.540823",
"0.53795105",
"0.5342376",
"0.5280446",
"0.52239424",
"0.52239424",
"0.51792663",
"0.51792663",
"0.51792663",
"0.5109144",
"0.5057882",
"0.5050363",
"0.5030301",
"0.5018952",
"0.5015047",
"0.49664378",
"0.4952... | 0.7200309 | 0 |
Provides an organization from its given ID. | def get_organization(
self, organization_id: Union[str, int], *, params: Optional[dict] = None
) -> "resource_types.Organization":
return communicator.Organization(self.__requester).from_id(
organization_id=organization_id, parameters=params
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_organization(self, id: str) -> dict[str, Any]:\n params = {}\n\n return self.client.get(self._url(id), params=params)",
"def organization(self, organization_id):\r\n return organizations.Organization(self, organization_id)",
"def find_organization(self):\n if self.org_id is ... | [
"0.7779527",
"0.7667834",
"0.72960305",
"0.7177982",
"0.6943155",
"0.6880863",
"0.6874825",
"0.6787914",
"0.6783364",
"0.6768005",
"0.6724089",
"0.67040336",
"0.6621863",
"0.65592504",
"0.653614",
"0.6531504",
"0.64872956",
"0.64778906",
"0.6453674",
"0.64502835",
"0.6436561"... | 0.79455 | 0 |
Provides the list of organizations of the current user. | def get_organizations(
self, *, params: Optional[dict] = None
) -> "resource_types.Organizations":
return communicator.Organizations(self.__requester).fetch(parameters=params) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def organizations(self):\n return self.get('{}/orgs'.format(ApiVersion.A1.value))",
"def list_all_organizations(ctx):\n pprint(ctx.obj.orgs.get().data)",
"async def get_organizations(request: Request):\n redis = request.app.state.redis\n organizations_obj = orjson.loads(await redis.get_key(\"influx... | [
"0.8252076",
"0.79823494",
"0.78466034",
"0.7764435",
"0.7730076",
"0.7687636",
"0.7638514",
"0.7531042",
"0.72897345",
"0.72628844",
"0.72628844",
"0.7150535",
"0.7096476",
"0.7093779",
"0.70538443",
"0.6993073",
"0.6938511",
"0.6844323",
"0.6752374",
"0.6648712",
"0.6563779... | 0.71319103 | 12 |
Provides the list of repositories of the current user. | def get_repositories(
self, *, params: Optional[dict] = None
) -> "resource_types.Repositories":
return communicator.Repositories(self.__requester).fetch(parameters=params) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def repositories(self, user_name=None):\n user_name = user_name if user_name else self._auth[0]\n data = self._request('GET', 'users', user_name)\n return data.repositories\n #ret_val = []\n #for repository in data.repositories:\n # ret_val.append(repository.name)\n ... | [
"0.8624754",
"0.81757784",
"0.7706611",
"0.7706166",
"0.7597628",
"0.7533269",
"0.7528032",
"0.75170326",
"0.74408704",
"0.74089473",
"0.7329396",
"0.7313573",
"0.72049135",
"0.7182676",
"0.7179828",
"0.7156892",
"0.7150683",
"0.7136331",
"0.6991477",
"0.6963982",
"0.6919021"... | 0.67244357 | 31 |
Provides the list of repositories of the given GitHub ID. | def get_repositories_from_github_id(
self, github_id: Union[str, int], *, params: Optional[dict] = None
) -> "resource_types.Repositories":
return communicator.Repositories(self.__requester).from_github_id(
github_id=int(github_id), parameters=params
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_repos(github_id):\r\n\r\n url = 'https://api.github.com/users/{}/repos'.format(github_id)\r\n response = requests.get(url)\r\n todos = json.loads(response.text)\r\n\r\n repo_list = []\r\n \r\n for data in todos:\r\n repo_list.append(data['name'])\r\n\r\n return repo_list",
"de... | [
"0.81455076",
"0.71791214",
"0.68482614",
"0.67864573",
"0.678607",
"0.67319983",
"0.6728848",
"0.6713311",
"0.67027485",
"0.66266894",
"0.6548572",
"0.65197384",
"0.6504157",
"0.65015703",
"0.64248604",
"0.6378858",
"0.6378281",
"0.6359549",
"0.6292143",
"0.62408435",
"0.617... | 0.7886239 | 1 |
Provides the list of repositories for the given login in the given provider. | def get_repositories_from_login(
self, login: str, *, provider: str = "github", params: Optional[dict] = None
) -> "resource_types.Repositories":
return communicator.Repositories(self.__requester).from_login(
login=login, provider=provider, parameters=params
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def repositories(self, user_name=None):\n user_name = user_name if user_name else self._auth[0]\n data = self._request('GET', 'users', user_name)\n return data.repositories\n #ret_val = []\n #for repository in data.repositories:\n # ret_val.append(repository.name)\n ... | [
"0.66285455",
"0.6528908",
"0.6485047",
"0.64401954",
"0.6372433",
"0.63584465",
"0.6312798",
"0.62660974",
"0.62343997",
"0.6229013",
"0.61398834",
"0.6103985",
"0.6090164",
"0.60706437",
"0.59627527",
"0.59548646",
"0.5917306",
"0.5913785",
"0.5908407",
"0.5907842",
"0.5902... | 0.83227384 | 0 |
Provides the repository from its given provider, ID or slug. | def get_repository_from_provider(
self,
provider: str,
repository_id_or_slug: Union[str, int],
*,
params: Optional[dict] = None,
) -> "resource_types.Repository":
return communicator.Repository(self.__requester).from_provider(
provider=provider,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_repository(\n self, repository_id_or_slug: Union[str, int], *, params: Optional[dict] = None\n ) -> \"resource_types.Repository\":\n\n return communicator.Repository(self.__requester).from_id_or_slug(\n repository_id_or_slug=repository_id_or_slug, parameters=params\n )",
... | [
"0.71772826",
"0.63128215",
"0.62667835",
"0.6212255",
"0.6113477",
"0.60990375",
"0.58293307",
"0.58286536",
"0.5804322",
"0.5787218",
"0.5753442",
"0.56915164",
"0.5691488",
"0.56619483",
"0.5660118",
"0.5628283",
"0.56201863",
"0.5602806",
"0.557673",
"0.5561464",
"0.55591... | 0.79773 | 0 |
Provides the repository from its given ID or slug. | def get_repository(
self, repository_id_or_slug: Union[str, int], *, params: Optional[dict] = None
) -> "resource_types.Repository":
return communicator.Repository(self.__requester).from_id_or_slug(
repository_id_or_slug=repository_id_or_slug, parameters=params
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_repo(repo_id):\n if repo_id == \"orphans\":\n pkgs = Database().db.get_orphans()\n else:\n pkgs = Database().db.get_repo_pkgs(repo_id)\n return render_template(\"repo.html\", \n title=\" - \"+repo_id,\n repos=Database().db.get_repos_names... | [
"0.6880181",
"0.66226876",
"0.64765483",
"0.6360771",
"0.6302806",
"0.626461",
"0.62416524",
"0.6215325",
"0.6213524",
"0.6175658",
"0.60762954",
"0.604203",
"0.6022187",
"0.59854496",
"0.5957842",
"0.59500873",
"0.5933728",
"0.59310895",
"0.59252787",
"0.58837426",
"0.586411... | 0.77257586 | 0 |
Provides the information of the current user. | def get_user(self, *, params: Optional[dict] = None) -> "resource_types.User":
return communicator.User(self.__requester).fetch(parameters=params) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def current_user_info():\n\n return current_user",
"def user_info(self):\n return self.auth.get_user_by_session()",
"def user_info(self):\n response = self.query('user_info')\n return response",
"def show_user_info(self):\n name = self.get_user_name()\n print(f'Name: {name.t... | [
"0.8667596",
"0.84123844",
"0.8305332",
"0.82019097",
"0.81598705",
"0.8110866",
"0.79796934",
"0.7841715",
"0.7836537",
"0.7836537",
"0.781808",
"0.78135294",
"0.77583146",
"0.77501225",
"0.7672192",
"0.7633349",
"0.76326025",
"0.7626147",
"0.7612622",
"0.7596718",
"0.759620... | 0.0 | -1 |
Provides the information of a user from its ID. | def get_user_from_id(
self, user_id: Union[str, int], *, params: Optional[dict] = None
) -> "resource_types.User":
return communicator.User(self.__requester).from_user_id(
user_id=user_id, parameters=params
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_user_info_by_id(self, user_id: int) -> dict:",
"def user_info(user_id):\n return User.query.filter_by(id=user_id).first()",
"def get_user(id):\n pass",
"def show_user_info(user_id):\n\n user = User.query.get_or_404(user_id)\n return render_template(\"user_details.html\", user=user)",
"d... | [
"0.8305874",
"0.8155866",
"0.77497923",
"0.7693863",
"0.7686031",
"0.7686031",
"0.76180446",
"0.75860786",
"0.7574494",
"0.75569916",
"0.75569916",
"0.7468606",
"0.7421179",
"0.7418215",
"0.738901",
"0.73247707",
"0.7319316",
"0.73184985",
"0.7311593",
"0.72912717",
"0.726198... | 0.0 | -1 |
Take a gaussian shell and confirm its power spectrum using shell_project_pspec. | def compare_averages_shell_pspec_dft():
select_radius = 5. #degrees
Nside=256
Npix = 12 * Nside**2
Omega = 4*np.pi/float(Npix)
Nfreq = 100
freqs = np.linspace(167.0, 177.0, Nfreq)
dnu = np.diff(freqs)[0]
Z = 1420/freqs - 1.
sig = 2.0
mu = 0.0
shell = np.random.normal(mu, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def womgau(hop):\n import numpy as np\n import logging\n import matplotlib.pyplot as plt\n from scipy.optimize import curve_fit\n from tmath.wombat.womwaverange import womwaverange\n from tmath.wombat.womget_element import womget_element\n from tmath.wombat.inputter import inputter\n from t... | [
"0.54461145",
"0.5179965",
"0.50951344",
"0.493999",
"0.4939673",
"0.4889197",
"0.48608387",
"0.48537308",
"0.48335385",
"0.48286435",
"0.4800673",
"0.4798589",
"0.47939384",
"0.47843185",
"0.47838107",
"0.47736582",
"0.47597453",
"0.47463492",
"0.47239593",
"0.47009686",
"0.... | 0.60930073 | 0 |
Adds robot model to the MJCF model. | def merge_robot(self, mujoco_robot):
self.robot = mujoco_robot
self.merge(mujoco_robot) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_model(self, model, delay_sort=True):\n assert isinstance(model, Model)\n\n if self.model_dict.has_key(model.model_id):\n raise ModelOverwrite()\n\n ## set default model if not set\n if self.default_model is None:\n self.default_model = model\n\n self... | [
"0.6300351",
"0.623976",
"0.61926067",
"0.61295176",
"0.61295176",
"0.6086574",
"0.5866401",
"0.577208",
"0.5743423",
"0.56547195",
"0.5634474",
"0.5634143",
"0.56233644",
"0.5622354",
"0.56155986",
"0.5605738",
"0.5589253",
"0.556396",
"0.5549465",
"0.55179256",
"0.54772717"... | 0.5588443 | 17 |
Adds arena model to the MJCF model. | def merge_arena(self, mujoco_arena):
self.arena = mujoco_arena
self.bin_offset = mujoco_arena.bin_abs
self.bin_size = mujoco_arena.table_full_size
self.bin2_body = mujoco_arena.bin2_body
self.merge(mujoco_arena) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def append(self,aModel):\n\n self.models.append(aModel)\n self.nmodes += len(aModel.modes)",
"def _attach_to_model(self, model):\n self._model = model",
"def add_ae(self, model, dataset, latent_options, model_paths, pre_process=None):\n ae = autoencoder(self.app, model, dataset, lat... | [
"0.56313676",
"0.49615818",
"0.49567008",
"0.4920569",
"0.4859373",
"0.48569682",
"0.48476598",
"0.4833981",
"0.47855198",
"0.47855198",
"0.47557554",
"0.4750223",
"0.47291082",
"0.47220296",
"0.46787572",
"0.46525794",
"0.4638592",
"0.46205002",
"0.4614683",
"0.46135435",
"0... | 0.560865 | 1 |
Adds physical objects to the MJCF model. | def merge_objects(self, mujoco_objects):
self.n_objects = len(mujoco_objects)
self.mujoco_objects = mujoco_objects
self.objects = [] # xml manifestation
self.max_horizontal_radius = 0
for obj_name, obj_mjcf in mujoco_objects.items():
self.merge_asset(obj_mjcf)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addObject(self):\n\t\tsel = mc.ls( sl = True, typ = 'transform' )\n\t\tif sel:\n\t\t\tself.objects_lw.addItems( sel )",
"def add_to_space(self, *objects):\n for obj in objects:\n self.space.add(obj)\n if isinstance(obj, pm.Body):\n self.bodies.append(obj)\n ... | [
"0.6231083",
"0.6163978",
"0.61568135",
"0.59532267",
"0.5918786",
"0.59032637",
"0.57899606",
"0.574225",
"0.57197064",
"0.5689045",
"0.5618526",
"0.5602999",
"0.55927825",
"0.53426486",
"0.5332537",
"0.5312929",
"0.53120226",
"0.5302265",
"0.5299465",
"0.5294262",
"0.528690... | 0.6004492 | 3 |
Adds visual objects to the MJCF model. | def merge_visual(self, mujoco_objects):
self.visual_obj_mjcf = []
for obj_name, obj_mjcf in mujoco_objects.items():
self.merge_asset(obj_mjcf)
# Load object
obj = obj_mjcf.get_visual(name=obj_name, site=False)
self.visual_obj_mjcf.append(obj)
s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addObjects(self):\n\n self.root = self.addRoot()\n vTemp = transform.getOffsetPosition(self.root, [0, 1, 0])\n self.top_loc = self.addLoc(\"top\", self.root, vTemp)\n centers = [self.root, self.top_loc]\n self.dispcrv = self.addDispCurve(\"crv\", centers)\n\n vTemp = t... | [
"0.64129865",
"0.6372637",
"0.625703",
"0.6190473",
"0.6069831",
"0.6058175",
"0.60520357",
"0.6046985",
"0.5969594",
"0.59651613",
"0.5939097",
"0.5872474",
"0.58611226",
"0.5806287",
"0.57963556",
"0.5793267",
"0.5742596",
"0.57081103",
"0.5706335",
"0.57024294",
"0.5668408... | 0.7002316 | 0 |
Samples quaternions of random rotations along the zaxis. | def sample_quat(self):
if self.z_rotation:
rot_angle = np.random.uniform(high=2 * np.pi, low=0)
return [np.cos(rot_angle / 2), 0, 0, np.sin(rot_angle / 2)]
return [1, 0, 0, 0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def random_quaternions(count=100):\n rands = np.random.rand(count,3)\n root_1 = np.sqrt(rands[:,0])\n minus_root_1 = np.sqrt(1-rands[:,0])\n two_pi_2 = np.pi*2*rands[:,1]\n two_pi_3 = np.pi*2*rands[:,2]\n \n res = np.zeros((count,4))\n res[:,0] = minus_root_1*np.sin(two_pi_2)\n res[:,1] ... | [
"0.7073986",
"0.68722045",
"0.6529664",
"0.6503195",
"0.6345796",
"0.6336485",
"0.6277915",
"0.61840326",
"0.61288977",
"0.60825557",
"0.6078604",
"0.60223764",
"0.60217965",
"0.60030395",
"0.6001181",
"0.5951943",
"0.59054774",
"0.58579105",
"0.58181906",
"0.57951933",
"0.57... | 0.7299934 | 0 |
Places objects randomly until no collisions or max iterations hit. | def place_objects(self):
placed_objects = []
index = 0
np.random.seed(300)
# place objects by rejection sampling
for _, obj_mjcf in self.mujoco_objects.items():
horizontal_radius = obj_mjcf.get_horizontal_radius()
bottom_offset = obj_mjcf.get_bottom_offset... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spawn_obstacles(self):\n self.obstacle_sprites.empty()\n number_of_obstacles = random.randint(MIN_OBSTACLES, MAX_OBSTACLES)\n while len(self.obstacle_sprites) < number_of_obstacles:\n obstacle = Obstacle(random.randrange(0, WIDTH), random.randrange(HEIGHT - 500, HEIGHT))\n ... | [
"0.6649374",
"0.6615201",
"0.64481175",
"0.6212739",
"0.6065585",
"0.6065585",
"0.6060398",
"0.6040957",
"0.6012398",
"0.6007238",
"0.5996292",
"0.59452283",
"0.5914823",
"0.59141505",
"0.5879403",
"0.5825326",
"0.58152974",
"0.57988673",
"0.57517725",
"0.5739899",
"0.5738482... | 0.69110835 | 0 |
Places visual objects randomly until no collisions or max iterations hit. | def place_visual(self):
index = 0
bin_pos = string_to_array(self.bin2_body.get("pos"))
bin_size = self.bin_size
for _, obj_mjcf in self.visual_objects:
bin_x_low = bin_pos[0]
bin_y_low = bin_pos[1]
if index == 0 or index == 2:
bin_x_l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fill(obj, prob = 1, collide_obj = None, collide_callback = None) :\n for x in range(int(Globals.instance.WIDTH/Globals.instance.GRID_SIZE)):\n for y in range(int(Globals.instance.HEIGHT/Globals.instance.GRID_SIZE)):\n if random.uniform(0, 1) > prob:\n continue\n ... | [
"0.6690254",
"0.6616007",
"0.64516664",
"0.64507973",
"0.64082336",
"0.6398577",
"0.6385337",
"0.6320666",
"0.6147977",
"0.6133578",
"0.6133578",
"0.6133037",
"0.6108902",
"0.6108902",
"0.6108902",
"0.6084032",
"0.6068002",
"0.606773",
"0.6066637",
"0.60568565",
"0.60369223",... | 0.0 | -1 |
Apply a patterning operator on a mesh through general transformation. | def patterning(mesh, operator):
operators = {
'conway_dual': conway_dual,
'conway_join': conway_join,
'conway_ambo': conway_ambo,
'conway_kis': conway_kis,
'conway_needle': conway_needle,
'conway_zip': conway_zip,
'conway_truncate': conway_truncate,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transform_mesh_filter(*args, **kwargs):\n import itk\n instance = itk.TransformMeshFilter.New(*args, **kwargs)\n return instance.__internal_call__()",
"def manifold_and_triangulate():\n # Switch in edit mode \n bpy.ops.object.mode_set(mode='EDIT')\n\n # Deselect everything\n ... | [
"0.5618558",
"0.5414091",
"0.5391252",
"0.538712",
"0.53303236",
"0.5186021",
"0.5045422",
"0.50429285",
"0.5039544",
"0.5029276",
"0.5006718",
"0.49956977",
"0.4982048",
"0.49593455",
"0.49355075",
"0.49018618",
"0.48980793",
"0.48942378",
"0.48899797",
"0.48395935",
"0.4818... | 0.7581529 | 0 |
>>> _map_dtype(np.dtype(np.int32)) int32 >>> _map_dtype(np.dtype(np.int64)) int64 >>> _map_dtype(np.dtype(np.object)) PyObject >>> _map_dtype(np.dtype(np.float64)) double >>> _map_dtype(np.dtype(np.complex128)) complex128 | def map_dtype(dtype):
item_idx = int(math.log(dtype.itemsize, 2))
if dtype.kind == 'i':
return [int8, int16, int32, int64][item_idx]
elif dtype.kind == 'u':
return [uint8, uint16, uint32, uint64][item_idx]
elif dtype.kind == 'f':
if dtype.itemsize == 2:
pass # half fl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _map_data_types(dtype):\n return _data_type_map[dtype]",
"def datatype_map(dtype):\n # TODO: add datetype conversion\n if 'float' in dtype:\n return 'numeric'\n elif 'int' in dtype:\n return 'int'\n elif 'bool' in dtype:\n return 'boolean'\n else:\n return 'text'... | [
"0.80567575",
"0.7175208",
"0.7003725",
"0.6944843",
"0.69013226",
"0.6860262",
"0.683389",
"0.68223584",
"0.6821523",
"0.68193454",
"0.6785528",
"0.6780237",
"0.6765619",
"0.67386276",
"0.6680076",
"0.66334206",
"0.6630267",
"0.6590078",
"0.65894043",
"0.65669954",
"0.653415... | 0.8565042 | 0 |
Desenha o labirinto representado no modelo model. | def draw(self, state):
if state is None:
state = self.model.current_state
for row in range(len(self.model.maze.walls)):
self.__draw_row_division()
print(" {0:2d} ".format(row), end='') # Imprime número da linha
for col in range(len(self.model.maze.walls[0... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def model(self):",
"def model(self):",
"def model(self):",
"def model(self):",
"def model(self):",
"def __init__(self):\n self.model = None",
"def __init__(self):\n self.model = None",
"def create_model(self):\n self.model = None\n pass",
"def save_model(self, request, o... | [
"0.55984116",
"0.55984116",
"0.55984116",
"0.55984116",
"0.55984116",
"0.5581929",
"0.5581929",
"0.5559378",
"0.5522319",
"0.54893225",
"0.54143155",
"0.54143155",
"0.54143155",
"0.5379634",
"0.53113645",
"0.5260471",
"0.5246865",
"0.52457726",
"0.52361137",
"0.522273",
"0.52... | 0.0 | -1 |
Transpose iload and istore. Must be fix in a future version. | def fix_iload(self):
# Fixme : store in a good way and in the right type istore and iload
for i in range(len(self.iload)):
self.iload[i] = np.ascontiguousarray(self.iload[i].T, dtype=np.int32)
self.istore = np.ascontiguousarray(self.istore.T, dtype=np.int32) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transpose():",
"def transpose_load_concat(self, **kwargs):\n if self.mask_train:\n datamask=self.add_mask()\n thedatas={}\n for key, value in kwargs.items():\n if not self.mask_train:\n thedatas[key]=value.X_train.transpose('a','x','y','features').val... | [
"0.5811776",
"0.57074726",
"0.5681151",
"0.5640245",
"0.55777746",
"0.5351398",
"0.5351398",
"0.52928823",
"0.5287192",
"0.5227838",
"0.52135694",
"0.5213067",
"0.5190803",
"0.5118121",
"0.5108729",
"0.5093582",
"0.5092675",
"0.50697315",
"0.50460935",
"0.50371075",
"0.500618... | 0.684812 | 0 |
Compute the distribution function at the equilibrium with the value on the border. | def prepare_rhs(self, simulation):
nv = simulation.container.nv
sorder = simulation.container.sorder
nspace = [1] * (len(sorder) - 1)
v = self.stencil.get_all_velocities()
gpu_support = simulation.container.gpu_support
for key, value in self.value_bc.items():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def erfc(x):\n return 0.0",
"def gaussed_value(self):\n from random import gauss\n return sorted([0, int(gauss(self.value, self.sigma)), \\\n (self.size*8)-1])[1]",
"def normalizefunction(self , values):\n maxv = np... | [
"0.5741531",
"0.5684328",
"0.5653153",
"0.5638879",
"0.55996156",
"0.5574182",
"0.55577606",
"0.5529009",
"0.5514495",
"0.5494531",
"0.5486149",
"0.547287",
"0.54722273",
"0.54658103",
"0.54658103",
"0.5454037",
"0.54514307",
"0.5434385",
"0.54310715",
"0.54193836",
"0.541202... | 0.0 | -1 |
Update distribution functions with this boundary condition. | def update(self, ff, **kwargs):
from .symbolic import call_genfunction
args = self._get_args(ff)
args.update(kwargs)
call_genfunction(self.function, args) # pylint: disable=no-member | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, function_values, es, bounds=None):\r\n if bounds is None:\r\n bounds = self.bounds\r\n if bounds is None or (bounds[0] is None and bounds[1] is None): # no bounds ==> no penalty\r\n return self # len(function_values) * [0.0] # case without voilations\r\n\r\n ... | [
"0.6606664",
"0.64178854",
"0.6225716",
"0.6151874",
"0.60961413",
"0.6093528",
"0.5998069",
"0.59092504",
"0.59061515",
"0.58915484",
"0.5869262",
"0.5866838",
"0.586291",
"0.58489245",
"0.5843187",
"0.583318",
"0.58013886",
"0.58013636",
"0.5791642",
"0.57863945",
"0.576748... | 0.0 | -1 |
Move arrays needed to compute the boundary on the GPU memory. | def move2gpu(self):
if self.generator.backend.upper() == "LOOPY":
try:
import pyopencl as cl
import pyopencl.array # pylint: disable=unused-variable
from .context import queue
except ImportError:
raise ImportError("Please i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _data_move_out_last_dim_lt_one_block(tik_inst, dst, src, data_pos_info):\n sub_axis_1, sub_axis_0, axis_0, axis_1, axis_2, out_offset = data_pos_info\n data_size_one_block = _get_elment_cnt_one_block(src.dtype)\n\n with tik_inst.if_scope(sub_axis_1 == 1):\n with tik_inst.if_scope(sub_axis_0 * a... | [
"0.5812451",
"0.5725411",
"0.5472441",
"0.545434",
"0.54450196",
"0.54422855",
"0.5420267",
"0.53995526",
"0.5396849",
"0.53827024",
"0.5343788",
"0.53435355",
"0.5315347",
"0.5311603",
"0.52795476",
"0.52631",
"0.5237792",
"0.52351785",
"0.5228774",
"0.5220994",
"0.5220994",... | 0.6041597 | 0 |
Compute the indices that are needed (symmertic velocities and space indices). | def set_iload(self):
k = self.istore[0]
ksym = self.stencil.get_symmetric()[k][np.newaxis, :]
v = self.stencil.get_all_velocities()
indices = self.istore[1:] + v[k].T
self.iload.append(np.concatenate([ksym, indices])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def indices_and_currents_TSC_2D( charge_electron, positions_x, positions_y, velocity_x, velocity_y,\\\n x_grid, y_grid, ghost_cells, length_domain_x, length_domain_y, dt ):\n \n \n positions_x_new = positions_x + velocity_x * dt\n positions_y_new = positions_y + velo... | [
"0.70425975",
"0.6227534",
"0.621245",
"0.61198896",
"0.6050179",
"0.60492086",
"0.59963256",
"0.59747845",
"0.5971784",
"0.5960889",
"0.5925465",
"0.5918824",
"0.5916217",
"0.5899766",
"0.5848567",
"0.5788059",
"0.5782234",
"0.5770706",
"0.5726879",
"0.5722692",
"0.5709878",... | 0.0 | -1 |
Compute and set the additional terms to fix the boundary values. | def set_rhs(self):
k = self.istore[:, 0]
ksym = self.stencil.get_symmetric()[k]
self.rhs[:] = self.feq[k, np.arange(k.size)] - self.feq[ksym, np.arange(k.size)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculateElementBoundaryCoefficients(self):\n pass",
"def update(self):\n\n terms_toRemove = []\n\n for termIndex, [term_constantFactor, term_unknowns_attributeAddresses] in enumerate(self.LHS):\n\n # Check if coefficient is 0 - then no need to process any of the unknowns sinc... | [
"0.59818715",
"0.59583765",
"0.5903426",
"0.5859693",
"0.58076525",
"0.5784628",
"0.5665552",
"0.5640563",
"0.5586638",
"0.5551454",
"0.5532172",
"0.5490747",
"0.54334694",
"0.5426477",
"0.5416738",
"0.54091454",
"0.54014874",
"0.5349996",
"0.5336917",
"0.5335465",
"0.5335465... | 0.52924377 | 25 |
Generate the numerical code. | def generate(self, sorder):
from .generator import For
from .symbolic import nx, ny, nz, indexed, ix
ns = int(self.stencil.nv_ptr[-1])
dim = self.stencil.dim
istore, iload, ncond = self._get_istore_iload_symb(dim)
rhs, _ = self._get_rhs_dist_symb(ncond)
idx = I... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def code(self):\n if not self._code:\n filename = '<fluxtools function %s>' % self.tag\n self._code = compile(self.math, filename, mode='eval')\n return self._code",
"def _get_random_number_code(self):\r\n return \"str(random.randint(0, 1e9))\"",
"def number(self):",
... | [
"0.66350216",
"0.6155325",
"0.6070667",
"0.60567296",
"0.6001382",
"0.5999806",
"0.5950534",
"0.5930682",
"0.58927596",
"0.5881666",
"0.5805855",
"0.57972014",
"0.5767194",
"0.5750545",
"0.5731919",
"0.5724899",
"0.57187545",
"0.56876415",
"0.5651061",
"0.564188",
"0.5631152"... | 0.0 | -1 |
Return the generated function | def function(self):
return self.generator.module.bounce_back | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getFunction(self) -> ghidra.program.model.listing.Function:\n ...",
"def gen_function(self, function):\n if function.body:\n self.gen_function_def(function)",
"def func ( self ) :\n return self.__func",
"def func ( self ) :\n return self.__func",
"def __call... | [
"0.72852004",
"0.7195862",
"0.7117405",
"0.70892036",
"0.7076999",
"0.6858654",
"0.6826619",
"0.67727506",
"0.67657286",
"0.6740471",
"0.67363507",
"0.67158663",
"0.6688514",
"0.6664095",
"0.665405",
"0.6650802",
"0.66507447",
"0.66498697",
"0.6646827",
"0.6641116",
"0.66322"... | 0.0 | -1 |
Compute the indices that are needed (symmertic velocities and space indices). | def set_iload(self):
k = self.istore[0]
ksym = self.stencil.get_symmetric()[k]
v = self.stencil.get_all_velocities()
iload1 = np.zeros(self.istore.shape, dtype=np.int32)
iload2 = np.zeros(self.istore.shape, dtype=np.int32)
mask = self.distance < 0.5
iload1[0, ma... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def indices_and_currents_TSC_2D( charge_electron, positions_x, positions_y, velocity_x, velocity_y,\\\n x_grid, y_grid, ghost_cells, length_domain_x, length_domain_y, dt ):\n \n \n positions_x_new = positions_x + velocity_x * dt\n positions_y_new = positions_y + velo... | [
"0.70425975",
"0.6227534",
"0.621245",
"0.61198896",
"0.6050179",
"0.60492086",
"0.59963256",
"0.59747845",
"0.5971784",
"0.5960889",
"0.5925465",
"0.5918824",
"0.5916217",
"0.5899766",
"0.5848567",
"0.5788059",
"0.5782234",
"0.5770706",
"0.5726879",
"0.5722692",
"0.5709878",... | 0.0 | -1 |
Compute and set the additional terms to fix the boundary values. | def set_rhs(self):
k = self.istore[:, 0]
ksym = self.stencil.get_symmetric()[k]
self.rhs[:] = self.feq[k, np.arange(k.size)] - self.feq[ksym, np.arange(k.size)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculateElementBoundaryCoefficients(self):\n pass",
"def update(self):\n\n terms_toRemove = []\n\n for termIndex, [term_constantFactor, term_unknowns_attributeAddresses] in enumerate(self.LHS):\n\n # Check if coefficient is 0 - then no need to process any of the unknowns sinc... | [
"0.59818715",
"0.59583765",
"0.5903426",
"0.5859693",
"0.58076525",
"0.5784628",
"0.5665552",
"0.5640563",
"0.5586638",
"0.5551454",
"0.5532172",
"0.5490747",
"0.54334694",
"0.5426477",
"0.5416738",
"0.54091454",
"0.54014874",
"0.5349996",
"0.5336917",
"0.5335465",
"0.5335465... | 0.52924377 | 24 |
Generate the numerical code. | def generate(self, sorder):
from .generator import For
from .symbolic import nx, ny, nz, indexed, ix
ns = int(self.stencil.nv_ptr[-1])
dim = self.stencil.dim
istore, iload, ncond = self._get_istore_iload_symb(dim)
rhs, dist = self._get_rhs_dist_symb(ncond)
idx ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def code(self):\n if not self._code:\n filename = '<fluxtools function %s>' % self.tag\n self._code = compile(self.math, filename, mode='eval')\n return self._code",
"def _get_random_number_code(self):\r\n return \"str(random.randint(0, 1e9))\"",
"def number(self):",
... | [
"0.66350216",
"0.6155325",
"0.6070667",
"0.60567296",
"0.6001382",
"0.5999806",
"0.5950534",
"0.5930682",
"0.58927596",
"0.5881666",
"0.5805855",
"0.57972014",
"0.5767194",
"0.5750545",
"0.5731919",
"0.5724899",
"0.57187545",
"0.56876415",
"0.5651061",
"0.564188",
"0.5631152"... | 0.0 | -1 |
Return the generated function | def function(self):
return self.generator.module.Bouzidi_bounce_back | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getFunction(self) -> ghidra.program.model.listing.Function:\n ...",
"def gen_function(self, function):\n if function.body:\n self.gen_function_def(function)",
"def func ( self ) :\n return self.__func",
"def func ( self ) :\n return self.__func",
"def __call... | [
"0.72852004",
"0.7195862",
"0.7117405",
"0.70892036",
"0.7076999",
"0.6858654",
"0.6826619",
"0.67727506",
"0.67657286",
"0.6740471",
"0.67363507",
"0.67158663",
"0.6688514",
"0.6664095",
"0.665405",
"0.6650802",
"0.66507447",
"0.66498697",
"0.6646827",
"0.6641116",
"0.66322"... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.