Set of the variable in this list
333425
def names(self):
        """"""
        ret = set()
        for arr in self:
            if isinstance(arr, InteractiveList):
                ret.update(arr.names)
            else:
                ret.add(arr.name)
        return ret
982301
def _var(self):
        
        class Variables(object):
            def __getitem__(_self, name):
                return self.getVariable(name)

            def __setitem__(_self, name, value):
                self.getVariable(name).setValue(value)

            def __iter__(_self):
                return self.getVariables()

        return Variables()
1310328
public final Set<Variable> vars() {
        if (vars == null) {
            ImmutableSet.Builder<Variable> builder = ImmutableSet.<Variable>builder().add(start());
            Variable end = end();
            if (end != null) builder.add(end);
            builder.addAll(otherVars());
            vars = builder.build();
        }

        return vars;
    }
876599
def fixedvar(self):
        
        possible = [m for m in self.members.values() if not m.is_custom]
        #If any of the possible variables is not allocatable or pointer, it will always
        #have a value and we can just use that.
        sufficient = [m for m in possible if "allocatable" not in m.modifiers
                      and "pointer" not in m.modifiers]
        if len(sufficient) > 0:
            return [sufficient[0].name]
        else:
            return [m.name for m in possible]
572657
public SortedSet<Variable> variables() {
    if (this.variables == null) {
      this.variables = new TreeSet<>();
      for (final Formula f : this.formulas)
        this.variables.addAll(f.variables());
    }
    return this.variables;
  }
570918
def p_genvarlist(self, p):
        ''
        p[0] = p[1] + (p[3],)
        p.set_lineno(0, p.lineno(1))
88892
def set_variable(self, start, variable):
        

        size = variable.size if variable.size is not None else 1

        self.set_object(start, variable, size)
908311
protected void initVariables(){
    	int ensembleSize = (int)this.memberCountOption.getValue();
        this.ensemble = new Classifier[ensembleSize];
        this.ensembleAges = new double[ensembleSize];
        this.ensembleWindows = new int[ensembleSize][(int)this.evaluationSizeOption.getValue()];    
    }
1027669
def add_var(self, var):
        
        if var.name in [v.name for v in self.vars]:
            logger.error("Variable set named '%s' already exists." % var.name)
            return

        var.i1 = self.var_N
        var.iN = self.var_N + var.N - 1
        self.vars.append(var)
140254
def variable_names(self):
        
        result = []
        names = javabridge.call(self.jobject, "getVariableNames", "()Ljava/util/Set;")
        for name in javabridge.iterate_collection(names):
            result.append(javabridge.to_string(name))
        return result
433500
def set(self, num):
        
        self._value = str(round(float(num), self.nplaces))
        self._variable.set(self._value)
1293857
function(list) {

                if (Array.isArray(list)) {

                    this.a.push.apply(this.a, list);

                } else {

                    for (var __$0 = (list)[Symbol.iterator](), __$1; __$1 = __$0.next(), !__$1.done;)
                        { var item$0 = __$1.value; this.a.push(item$0); }
                }

                return this;
            }
857773
def vars_(self):
        
        return [x for x in self[self.current_scope].values() if x.class_ == CLASS.var]
61699
def p_variable_declaration_list_noin(self, p):
        
        if len(p) == 2:
            p[0] = [p[1]]
        else:
            p[1].append(p[3])
            p[0] = p[1]
142965
def var_set(self, session, **kwargs):
        
        if not kwargs:
            session.write_line(
                self._utils.make_table(
                    ("Name", "Value"), session.variables.items()
                )
            )
        else:
            for name, value in kwargs.items():
                name = name.strip()
                session.set(name, value)
                session.write_line("{0}={1}", name, value)
406568
def variables(self):
        
        p = lambda o: isinstance(o, Variable) and self._docfilter(o)
        return sorted(filter(p, self.doc.values()))
520350
def _transform(self, var):
        '''  '''
        self.collection.variables.pop(var.name)
        return var.values