The expanded lists of values generated from the parameter fields

        :returns: list<list>, outer list is for each parameter, inner loops are that
        parameter's values to loop through
160387
def ranges(self):
        
        steps = []
        for p in self._parameters:
            # inclusive range
            if p['parameter'] == 'filename':
                steps.append(p['names'])
            else:
                if p['step'] > 0:
                    start = p['start']
                    stop = p['stop']
                    if start > stop:
                        step = p['step']*-1
                    else:
                        step = p['step']
                    # nsteps = np.ceil(np.around(abs(start - stop), 4) / p['step'])
                    nsteps = self.nStepsForParam(p)
                    # print 'nsteps', np.around(abs(start - stop), 4), p['step']
                    # print 'start, stop, steps', start, stop, nsteps
                    step_tmp = np.linspace(start, start+step*(nsteps-2), nsteps-1)
                    # print 'step_tmp', step_tmp

                    # if step_tmp[-1] != stop:
                    step_tmp = np.append(step_tmp,stop)
                    # print 'step range', step_tmp

                    steps.append(np.around(step_tmp,4))
                else:
                    assert p['start'] == p['stop']
                    steps.append([p['start']])
        return steps
293975
def build_parameters(self):
        
        param_bits = []
        for name in self.parameters:
            param_bits.extend(self.build_parameter_by_name(name) or [])
        return param_bits
635151
public List<Parameter> getAllParameters() {
        List<Parameter> ret = new ArrayList<Parameter>();

        // Parameters within statements
        if (statements != null) {
            for (final Statement stmt : statements)
                ret.addAll(stmt.getAllParameters());
        }

        // Parameters within nested statement groups
        if (statementGroups != null) {
            for (final StatementGroup sg : statementGroups)
                ret.addAll(sg.getAllParameters());
        }

        return ret;
    }
857180
def iter_fields(self):
        
        def generator(path, values):
            for name,value in sorted(values.items()):
                if isinstance(value, ValueTree):
                    for inner in generator(path + name, value._values):
                        yield inner
                else:
                    yield (path, name, value)
        return generator(Path([]), self._values)
1197045
def getparams(self, param):
        

        return list(cparam for cparam in self.values() if cparam == param)
1163977
def parameters(self):
        
        all_parameters = collections.OrderedDict()

        for component in self._components.values():

            for par in component.shape.parameters.values():

                all_parameters[par.path] = par

        return all_parameters
335811
public List<T> values() {
        List<T> result = new ArrayList<T>();
        for (Iterator<T> itr = iterator(); itr.hasNext(); ) {
            result.add(itr.next());
        }
        return result;
    }
1279032
public List<Integer> listValues() {
		ArrayList<Integer> list = new ArrayList<Integer>(getRange());
		for (int i = getMin(); i <= getMax(); i++) {
			list.add(i);
		}
		return list;
	}
1018158
def values(cls, dataset, dimension, expanded, flat):
        
        if not dataset.data:
            return np.array([])
        values = []
        ds = cls._inner_dataset_template(dataset)
        for d in dataset.data:
            ds.data = d
            dvals = ds.interface.values(ds, dimension, expanded, flat)
            if not len(dvals):
                continue
            elif expanded:
                values.append(dvals)
                values.append([np.NaN])
            else:
                values.append(dvals)
        if not values:
            return np.array([])
        elif expanded:
            return np.concatenate(values[:-1])
        else:
            return np.concatenate(values)
1211602
def expandParameters(*args):
    
    count = 1
    for arg in args:
        count = max(len(arg[0]), count)
    results = []
    for arg in args:
        results.append(expandValues(arg[0], count, args[1]))
    return tuple(results)
618815
def computed_fitting_parameters(self):
        
        fitted_parameters = []
        for (i, v) in enumerate(self.fitting_parameters):
            param = v.copy()
            param['value'] = self.fitted_parameters[i] * prefix_factor(param)**(-1)
            fitted_parameters.append(param)

        return fitted_parameters
443810
public List<FacesConfigFlowDefinitionInboundParameterType<FacesConfigFlowDefinitionType<T>>> getAllInboundParameter()
   {
      List<FacesConfigFlowDefinitionInboundParameterType<FacesConfigFlowDefinitionType<T>>> list = new ArrayList<FacesConfigFlowDefinitionInboundParameterType<FacesConfigFlowDefinitionType<T>>>();
      List<Node> nodeList = childNode.get("inbound-parameter");
      for(Node node: nodeList)
      {
         FacesConfigFlowDefinitionInboundParameterType<FacesConfigFlowDefinitionType<T>>  type = new FacesConfigFlowDefinitionInboundParameterTypeImpl<FacesConfigFlowDefinitionType<T>>(this, "inbound-parameter", childNode, node);
         list.add(type);
      }
      return list;
   }
176307
def bounds(self):
        
        bounds = []
        for p in self.params:
            if p.fixed:
                if p.value >= 0.0:
                    bounds.append([np.nextafter(p.value, 0), p.value])
                else:
                    bounds.append([p.value, np.nextafter(p.value, 0)])
            else:
                bounds.append([p.min, p.max])
        return bounds
315709
public List<FacesConfigFlowDefinitionFlowCallOutboundParameterType<FacesConfigFlowDefinitionFlowCallType<T>>> getAllOutboundParameter()
   {
      List<FacesConfigFlowDefinitionFlowCallOutboundParameterType<FacesConfigFlowDefinitionFlowCallType<T>>> list = new ArrayList<FacesConfigFlowDefinitionFlowCallOutboundParameterType<FacesConfigFlowDefinitionFlowCallType<T>>>();
      List<Node> nodeList = childNode.get("outbound-parameter");
      for(Node node: nodeList)
      {
         FacesConfigFlowDefinitionFlowCallOutboundParameterType<FacesConfigFlowDefinitionFlowCallType<T>>  type = new FacesConfigFlowDefinitionFlowCallOutboundParameterTypeImpl<FacesConfigFlowDefinitionFlowCallType<T>>(this, "outbound-parameter", childNode, node);
         list.add(type);
      }
      return list;
   }
1220316
def get_bounds(self):
        
        bounds = []

        for variable in self.space_expanded:
            bounds += variable.get_bounds()

        return bounds
110288
def parameters(self):
        
        parameters = []
        for task in self.tasks:
            parameters.extend(task.parameters)
        return parameters
265348
def values(self):
        
        enm = javabridge.call(self.jobject, "enumerateValues", "()Ljava/util/Enumeration;")
        if enm is None:
            return None
        else:
            return typeconv.enumeration_to_list(enm)