Add a symbol with key `name` to `scipy_data_fitting.Model.symbols`.
        Optionally, specify an alternative `string` to pass to [`sympy.Symbol`][1],
        otherwise `name` is used.

        [1]: http://docs.sympy.org/dev/modules/core.html#id4
774790
def add_symbol(self, name, string=None):
        
        if not string: string = name
        self.symbols[name] = sympy.Symbol(string)
509523
def _name_attribute_to_string(self, name):
        
        return "".join(
            "/{}={}".format(
                self._get_oid_name(attr.oid),
                attr.value,
            )
            for attr in name
        )
68208
def add(self, name: str, pattern: str) -> None:
        
        self.patterns[name] = URITemplate(
            pattern, converters=self.converters)
1312678
def get_symbol_train(network, data_shape, **kwargs):
    
    if network.startswith('legacy'):
        logging.warn('Using legacy model.')
        return symbol_builder.import_module(network).get_symbol_train(**kwargs)
    config = get_config(network, data_shape, **kwargs).copy()
    config.update(kwargs)
    return symbol_builder.get_symbol_train(**config)
63074
function mergeSymbolMaps(additionalSymbols?: Object): Object {
  const symbolMap = {}
  symbolMap.symbols = additionalSymbols
    ? { ...defaultSymbolMap.symbols, ...additionalSymbols.symbols }
    : { ...defaultSymbolMap.symbols }

  return symbolMap
}
250926
def add_params(self, **kw):
        
        for k, v in kw.items():
            if (k not in self.params) and (k not in self.specific_params):
                raise ParameterError('"%s" is not a valid parameter for %s'
                                     % (k, self.__class__.__name__))
            try:
                self.params[k].validate(v)
            except KeyError:
                self.specific_params[k].validate(v)

        self._orig_kwargs.update(kw)
        self.kwargs = self._orig_kwargs.copy()
246428
def _normalize_custom_param_name(name):
    

    replacements = (("\u2018", "'"), ("\u2019", "'"), ("\u201C", '"'), ("\u201D", '"'))
    for orig, replacement in replacements:
        name = name.replace(orig, replacement)
    return name
607763
def _create_symbol(self, id, symbolobj):
        """"""
        result = {'id': symbolobj.name, 'isPoint': False, 'isStroke': False, 'isFill': False}
        matcher = Mapfile._SYMBOL_NAME_REGEXP.match(symbolobj.name)
        if matcher:
            result['name'] = matcher.group(2)
            for c in matcher.group(1):
                field = Mapfile._STYLE_CHAR2NAME[c]
                result[field] = True
        else:
            result['name'] = symbolobj.name
            result['isPoint'] = result['isStroke'] = result['isFill'] = True
        return result
1347185
def _set_symbols(self, file_name, configure):
        

        self.symbols = []
        if file_name is None:
            file_name = os.path.join(os.path.dirname(os.path.dirname(
                os.path.dirname(os.path.realpath(__file__))
            )), 'symbols.xml')
        xmldoc = minidom.parse(file_name)
        symbols_xml = xmldoc.getElementsByTagName(
            'symbols'
        )[0].getElementsByTagName('symbol')
        for symbol_xml in symbols_xml:
            self.symbols.append({
                'symbol': symbol_xml.attributes['symbol'].value,
                'description': configure.get_parameter(
                    symbol_xml.attributes['description'].value
                )
            })
1007585
def addSignal(self, s):
        
        if s.nargs == -1:
            s.nargs = len([a for a in marshal.genCompleteTypes(s.sig)])
        self.signals[s.name] = s
        self._xml = None
1057728
def feature(name)
      if !name.is_a?(String) && !name.is_a?(Symbol)
        raise ArgumentError, "#{name} must be a String or Symbol"
      end

      @memoized_features[name.to_sym] ||= Feature.new(name, @adapter, instrumenter: instrumenter)
    end
924147
def _load_symbol(name):
    
    module_name, key = name.rsplit('.', 1)
    try:
        module = importlib.import_module(module_name)
    except ImportError as err:
        # it's possible the symbol is a class method
        module_name, class_name = module_name.rsplit('.', 1)
        module = importlib.import_module(module_name)
        cls = getattr(module, class_name, None)
        if cls:
            attr = getattr(cls, key, None)
        else:
            raise err
    else:
        attr = getattr(module, key, None)
    if not callable(attr):
        raise ValueError('%s is not callable (was %r)' % (name, attr))
    return attr
1342882
def deep_set_symbol_key(hash, key, value)
      if value.kind_of? Hash
        hash[key.to_sym] = value.inject({}) { |inner_hash, (inner_key, inner_value)| deep_set_symbol_key(inner_hash, inner_key, inner_value) }
      else
        hash[key.to_sym] = value
      end
      hash
    end
892436
def add(self, data_bytes):
        ''''''
        try:
            if isinstance(data_bytes, basestring):  # Python 2.7 compatibility
                data_bytes = map(ord, data_bytes)
        except NameError:
            if isinstance(data_bytes, str):  # This branch will be taken on Python 3
                data_bytes = map(ord, data_bytes)

        for b in data_bytes:
            self._crc ^= (b << 56) & Signature.MASK64
            for _ in range(8):
                if self._crc & (1 << 63):
                    self._crc = ((self._crc << 1) & Signature.MASK64) ^ Signature.POLY
                else:
                    self._crc <<= 1
1310916
def add_attribute(self, name, value):
        

        self.attributes.append(Attribute(name, value))
946573
def add(self, name: str, value: str) -> None:
        """"""
        norm_name = _normalized_headers[name]
        self._last_key = norm_name
        if norm_name in self:
            self._dict[norm_name] = (
                native_str(self[norm_name]) + "," + native_str(value)
            )
            self._as_list[norm_name].append(value)
        else:
            self[norm_name] = value
609855
def is_symbol_hooked(self, symbol_name):
        
        sym = self.loader.find_symbol(symbol_name)
        if sym is None:
            l.warning("Could not find symbol %s", symbol_name)
            return False
        hook_addr, _ = self.simos.prepare_function_symbol(symbol_name, basic_addr=sym.rebased_addr)
        return self.is_hooked(hook_addr)