Set self.symbols based on self.numbers and the periodic table.
761674
def set_default_symbols(self):
        """"""
        self.symbols = tuple(periodic[n].symbol for n in self.numbers)
1334842
def set_flag(self, value, flag, reset_val=False):
        """"""
        if not self.__dict__[flag]:
            self.__dict__[flag] = matrix(1.0, (len(self.__dict__[value]), 1),
                                         'd')
        for idx, item in enumerate(self.__dict__[value]):
            if item == 0:
                self.__dict__[flag][idx] = 0
                if reset_val:
                    self.__dict__[value][idx] = 1
797066
def _init_kwelems(self):
        """"""
        ret = set()
        if 'rcntobj' in self.kws:
            ret.add('dcnt')
            ret.add('D1')
        if 'tcntobj' in self.kws:
            ret.add('tcnt')
            ret.add('tfreq')
            ret.add('tinfo')
        return ret
899896
def free_symbols(self):
        """"""
        try:
            lhs_syms = self.lhs.free_symbols
        except AttributeError:
            lhs_syms = set()
        try:
            rhs_syms = self.rhs.free_symbols
        except AttributeError:
            rhs_syms = set()
        return lhs_syms | rhs_syms
1111312
private void setNumbers(int number, ArrayList numbers) {
        this.numbers = new ArrayList();
        this.numbers.add(Integer.valueOf(number));
        this.numbers.addAll(numbers);
    }
916643
def _set_flags(self, **flags):
        '''
        
        '''
        self._flags = enum.IntEnum('_flags', flags)
        self.__dict__.update(self._flags.__members__)
        self._patch_flag_doc()
463251
def set_code(self, code):
        """"""

        # Get attributes from code

        attributes = []
        strip = lambda s: s.strip('u').strip("'").strip('"')
        for attr_dict in parse_dict_strings(unicode(code).strip()[19:-1]):
            attrs = list(strip(s) for s in parse_dict_strings(attr_dict[1:-1]))
            attributes.append(dict(zip(attrs[::2], attrs[1::2])))

        if not attributes:
            return

        # Set widgets from attributes
        # ---------------------------

        # Figure attributes
        figure_attributes = attributes[0]

        for key, widget in self.figure_attributes_panel:
            try:
                obj = figure_attributes[key]
                kwargs_key = key + "_kwargs"
                if kwargs_key in figure_attributes:
                    widget.set_kwargs(figure_attributes[kwargs_key])

            except KeyError:
                obj = ""

            widget.code = charts.object2code(key, obj)

        # Series attributes
        self.all_series_panel.update(attributes[1:])
1178151
def _calculate(numbers, symbols):
        """"""
        if len(numbers) is 1:
            return numbers[0]

        precedence = [[pow], [mul, div], [add, sub]]

        # Find most important operation
        for op_group in precedence:
            for i, op in enumerate(symbols):
                if op in op_group:
                    # Apply operation
                    a = numbers[i]
                    b = numbers[i + 1]
                    result = MathService._applyBinary(a, b, op)
                    new_numbers = numbers[:i] + [result] + numbers[i + 2:]
                    new_symbols = symbols[:i] + symbols[i + 1:]

                    return MathService._calculate(new_numbers, new_symbols)
429115
def set_aromatic(self):
        """"""
        #XXX FIX ME
        # this probably shouldn't be here
        for atom in self.atoms:
            atom.aromatic = 1
            
        for bond in self.bonds:
            bond.aromatic = 1
            bond.bondorder = 1.5
            bond.bondtype = 4
            bond.symbol = ":"
            bond.fixed = 1

        self.aromatic = 1
1097299
def symbolize(number):
    """"""
    repeat, index = divmod(number - 1, len(SYMBOLS))
    return SYMBOLS[index] * (1 + repeat)
1073138
def get_atom_type_symbol(cls,calc,**kwargs):
        
        parameters = calc.out.output
        dictionary = parameters.get_dict()
        if 'basis_set' not in dictionary.keys():
            return None
        return sorted(dictionary['basis_set'].keys())
684900
def set(cls, values):
        
        cls.mrc_out_el.text = values.get("mrc", "")
        cls.oai_out_el.text = values.get("oai", "")
        cls.dc_out_el.text = values.get("dc", "")
        cls.filename = values.get("fn", "fn")

        cls.values = values
610232
def free_symbols(self):
        """"""
        return set.union(
            self.S.free_symbols, self.L.free_symbols, self.H.free_symbols)
467296
def _values(self):
        """"""
        return [abs(val) for val in super(Dot, self)._values if val != 0]
1290747
def symbols_to_prob(symbols):
    '''
    
    '''
    myCounter = Counter(symbols)

    N = float(len(list(symbols)))   # symbols might be a zip object in python 3

    for k in myCounter:
        myCounter[k] /= N

    return myCounter
73492
def _set_selectedGlyphNames(self, value):
        
        select = [self[name] for name in value]
        self.selectedGlyphs = select
752637
def set_symbol(self, symbol):
        """"""
        raise "Deprecated"
        self.symbol, self.bondtype, bondorder, self.equiv_class = \
                     BONDLOOKUP[symbol]
        if self.bondtype == 4:
            self.aromatic = 1
        else:
            self.aromatic = 0