The variable names for each of the arrays in this list
486529
def all_names(self):
        """"""
        return [
            _get_variable_names(arr) if not isinstance(arr, ArrayList) else
            arr.all_names
            for arr in self]
887773
def var_str(name, shape):
    

    size = prod(shape)
    ind = (indices(shape) + 1).reshape(-1, size)
    names = ['[' + ','.join(list(map(str, i))) + ']' for i in zip(*ind)]
    names[0] = '%s %s' % (name, names[0])
    return names
653281
def list_config_variables(self, offset):
        """"""

        names = sorted(self._config_variables)
        names = names[offset:offset + 9]
        count = len(names)

        if len(names) < 9:
            names += [0]*(9 - count)

        return [count] + names
1217014
public List<String> getAllVariables() {
        List<String> result = new ArrayList<String>();
        result.addAll(this.getAllLHSVariables());
        result.addAll(this.getAllRHSVariables());
        return result;
    }
166535
def VariablesValues(self, variables, t):
        
        # TODO: put interpolation in variables
        if (t < self.te) | (t > 0):
            i = t//self.ts  # time step
            ti = self.ts*i
            if type(variables) == list:
                values = []
                for variable in variables:
                    # interpolation
                    values.append(
                        variables.values[i]*((ti-t)/self.ts+1)+variables.values[i+1]*(t-ti)/self.ts)
                return values

            else:
                # interpolation
                return variables.values[i]*((ti-t)/self.ts+1)+variables.values[i+1]*(t-ti)/self.ts
        else:
            raise ValueError
1097143
function(_list,_prefix){
        var _arr = [];
        _u._$forEach(
            _list,function(v,i){
                _xbatch.p++;
                var _ref = _prefix+'-e'+_xbatch.p,
                    _value = __doSerialize(v,_prefix);
                if (!_value) return;
                _xbatch.m[_ref] = _value;
                _arr.push('reference:'+_ref);
            }
        );
        return 'Array:['+_arr.join(',')+']';
    }
35596
def varnames(self):
        
        # We must sort to preserve the order between calls.
        # The set comprehension is to drop the duplicates.
        return self._argnames + tuple(sorted({
            instr.arg
            for instr in self.instrs
            if instr.uses_varname and instr.arg not in self._argnames
        }))
416869
protected void getAllNamesAux(final List<String> vec) {
        vec.addAll(this.variables.keySet());
        if ( methods != null )
            vec.addAll(this.methods.keySet());
        if (this.parent != null)
            this.parent.getAllNamesAux(vec);
    }
979063
public final List<ObjectVariable> getObjectVariables() {
    List<ObjectVariable> objectVars = new ArrayList<ObjectVariable>();
    for (int i = 0; i < vars.length; i++) {
      if (vars[i] instanceof ObjectVariable) {
        objectVars.add((ObjectVariable) vars[i]);
      }
    }
    return objectVars;
  }
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()
220636
protected void syncScriptingVars(JavaCodeWriter tagWriter, int scope) {
        TagVariableInfo[] tagVarInfos = ti.getTagVariableInfos();
        VariableInfo[] varInfos = ti.getVariableInfo(collectedTagData.getTagData());

        if (varInfos == null)
            varInfos = new VariableInfo[0];
            
        if ((varInfos.length == 0) && (tagVarInfos.length == 0)) {
            return;
        }

        if (varInfos.length > 0) {
            for (int i = 0; i < varInfos.length; i++) {
                if (varInfos[i].getScope() == scope) {
                    tagWriter.print(varInfos[i].getVarName());
                    tagWriter.print(" = ((");
                    String className=varInfos[i].getClassName();
                    className = replaceCharacters(className); //PK40417 &gt;,&lt;,&amp;,<\\%, and %\\>
                    tagWriter.print(className);
                    tagWriter.print(") "+pageContextVar+".findAttribute(");    //PK65013
                    tagWriter.print(GeneratorUtils.quote(varInfos[i].getVarName()));
					tagWriter.print("))");
					// PK26741
					if(jspOptions.isUseRepeatInt() && isRepeatTag)
						tagWriter.println(".intValue();");
					else
                    	tagWriter.println(";");		// PK26741
                }
            }
        }
        else {
            for (int i = 0; i < tagVarInfos.length; i++) {
                if (tagVarInfos[i].getScope() == scope) {
                    String name = tagVarInfos[i].getNameGiven();
                    if (name == null) {
                        name = collectedTagData.getTagData().getAttributeString(tagVarInfos[i].getNameFromAttribute());
                    }
                    else if (tagVarInfos[i].getNameFromAttribute() != null) {
                        // alias
                        continue;
                    }
                    tagWriter.print(name);
					tagWriter.print(" = ((");
                    String className=tagVarInfos[i].getClassName();
                    className = replaceCharacters(className); //PK40417 &gt;,&lt;,&amp;,<\\%, and %\\>
                    tagWriter.print(className);
                    tagWriter.print(") "+pageContextVar+".findAttribute("); //PK65013
                    tagWriter.print(GeneratorUtils.quote(name));
					tagWriter.print("))");
					// PK26741
					if(jspOptions.isUseRepeatInt() && isRepeatTag)
						tagWriter.println(".intValue();");
					else
                    	tagWriter.println(";");		// PK26741
                }
            }
        }
    }
110727
def variables(self):
        
        variables = set()
        for v in self.nodes_iter():
            if isinstance(v, Clause):
                for l in v:
                    variables.add(l.variable)
            else:
                variables.add(v)
        return variables
1054423
public Collection<String> getVariableNames()
    {
        ImmutableSet.Builder<String> builder = ImmutableSet.builder();
        for ( ConfigurationKeyPart p : parts )
        {
            if ( p.isVariable() )
            {
                builder.add(p.getValue());
            }
        }

        return builder.build();
    }
595487
def get_input_var_names(self):
        
        in_vars = copy.copy(self.input_vars)
        for idx, var in enumerate(in_vars):
            if self._map_in_out(var) is not None:
                in_vars[idx] = self._map_in_out(var)
        return in_vars
1276047
private boolean eachVariableOccursOnlyOnce() {
        int lit;
        for (int i = 0; i < this.addedlits.size(); i++) {
            lit = this.addedlits.get(i);
            assert marked(lit) == 0;
            assert marked(-lit) == 0;
        }
        boolean res = true;
        for (int i = 0; i < this.addedlits.size(); i++) {
            lit = this.addedlits.get(i);
            if (marked(lit) != 0 || marked(-lit) != 0) { res = false; } else { mark(lit); }
        }
        unmark();
        return res;
    }
131559
public static String[] getVariableNames(NameSpace ns) {
        if (ns == null)
            return new String[0];
        return Stream.of(ns.getVariableNames())
                .filter(name->!name.matches("_?bsh.*"))
                .toArray(String[]::new);
    }
239632
def variable_matrix(
    variables: VarType, parent: str = None, iterator: str = "product"
) -> Iterable[Dict[str, YamlValue]]:
    
    _iters: Dict[str, Callable] = {"product": product, "zip": zip}
    _special_keys: Dict[str, Callable[[VarType, Any], Iterable[VarMatrix]]] = {
        "zip": iterator_zip,
        "product": iterator_product,
        "arange": iterator_arange,
        "chain": iterator_chain,
        "append": iterator_chain,
        "cycle": iterator_cycle,
        "repeat": iterator_cycle,
    }

    if isinstance(variables, dict):
        key_vars: List[List[Dict[str, YamlValue]]] = []

        # Handling of specialised iterators
        for key, function in _special_keys.items():
            if variables.get(key):
                item = variables[key]
                assert item is not None
                for val in function(item, parent):
                    key_vars.append(val)

                del variables[key]

        for key, value in variables.items():
            key_vars.append(list(variable_matrix(value, key, iterator)))

        logger.debug("key vars: %s", key_vars)

        # Iterate through all possible products generating a dictionary
        for i in _iters[iterator](*key_vars):
            logger.debug("dicts: %s", i)
            yield combine_dictionaries(i)

    # Iterate through a list of values
    elif isinstance(variables, list):
        for item in variables:
            yield from variable_matrix(item, parent, iterator)

    # Stopping condition -> we have either a single value from a list
    # or a value had only one item
    else:
        assert parent is not None
        yield {parent: variables}