Information about this parameter
514726
def describe(self):
        """"""
        desc = {
            'name': self.name,
            'description': self.description,
            # the Parameter might not have a type at all
            'type': self.type or 'unknown',
        }
        for attr in ['min', 'max', 'allowed', 'default']:
            v = getattr(self, attr)
            if v is not None:
                desc[attr] = v
        return desc
605942
def uv_parameter(check_point)
      Util3D.check_arg_type(::Vector3, check_point)
      mat = Matrix[[u_vector.x, u_vector.y, u_vector.z],
            [v_vector.x, v_vector.y, v_vector.z],
            [normal.x, normal.y, normal.z]]
      vec = (check_point - base_point).to_column_vector
      ans = mat.t.inv*vec
      return ans[0,0], ans[1,0]
    end
454736
private function extractRoutineParametersInfo(): void
  {
    $routine_parameters = MetaDataLayer::getRoutineParameters($this->routineName);
    foreach ($routine_parameters as $key => $routine_parameter)
    {
      if ($routine_parameter['parameter_name'])
      {
        $data_type_descriptor = $routine_parameter['dtd_identifier'];
        if (isset($routine_parameter['character_set_name']))
        {
          $data_type_descriptor .= ' character set '.$routine_parameter['character_set_name'];
        }
        if (isset($routine_parameter['collation_name']))
        {
          $data_type_descriptor .= ' collation '.$routine_parameter['collation_name'];
        }

        $routine_parameter['data_type_descriptor'] = $data_type_descriptor;

        $this->parameters[$key] = $routine_parameter;
      }
    }

    $this->updateParametersInfo();
  }
1132580
def _parametersAsIndex( self, ps ):
        """"""
        k = ""
        for p in sorted(ps.keys()):       # normalise the parameters
            v = ps[p]
            k = k + "{p}=[[{v}]];".format(p = p, v = v)
        return k
1142558
def getParam(self, name=None):
        
        if 'parameters' in self.keys():
            l = {x['name']: x['value'] for x in self['parameters'].values()}
            if name:
                if name in l.keys():
                    return l[name]
                else:
                    return False
            else:
                return l
76944
def parameter_vector(self):
        """"""
        return np.array([getattr(self, k) for k in self.parameter_names])
1300497
def calc_secondary_parameters(self):
        """"""
        self.c = 1./(self.k*special.gamma(self.n))
156063
def shared_parameters(self):
        
        if len(self) == 1:  # Not a vector
            return False
        else:
            params_thusfar = []
            for component in self.values():
                vars, params = seperate_symbols(component)
                if set(params).intersection(set(params_thusfar)):
                    return True
                else:
                    params_thusfar += params
            else:
                return False
1098686
def get_parameter_info(cls, obj, ansi=False,  show_values=True,
                           pattern=None, max_col_len=40):
        
        if cls.ppager is None: return ''
        if pattern is not None:
            obj = ParamFilter(obj, ParamFilter.regexp_filter(pattern))
            if len(obj.params()) <=1:
                return None
        param_info = cls.ppager.get_param_info(obj)
        param_list = cls.ppager.param_docstrings(param_info)
        if not show_values:
            retval = cls.ansi_escape.sub('', param_list) if not ansi else param_list
            return cls.highlight(pattern, retval)
        else:
            info = cls.ppager(obj)
            if ansi is False:
                info = cls.ansi_escape.sub('', info)
            return cls.highlight(pattern, info)
1100304
public String getParameterName() {
        if (parameterName == null) {
            Parameter parameter = getParameter();
            if (parameter.isNamePresent()) {
                parameterName = parameter.getName();
            }
        }

        return parameterName;
    }
499730
def print_parameters(self):
        
        print("Static: ", self.params_st)
        print("Thermal: ", self.params_th)
        print("Anharmonic: ", self.params_anh)
        print("Electronic: ", self.params_el)
1056254
def _find_scalar_parameter(expr):
    
    op = expr.op()

    if isinstance(op, ops.ScalarParameter):
        result = op, expr.get_name()
    else:
        result = None
    return lin.proceed, result
810564
def parameters(self, value):
        """"""
        self.W = value[0] if isinstance(value[0], GPUArray) else \
          gpuarray.to_gpu(value[0])
        self.b = value[1] if isinstance(value[0], GPUArray) else \
          gpuarray.to_gpu(value[1])
91069
public static String getParamInfo(Parameterizable p) {
      StringBuilder sb = new StringBuilder(p.getParameters().size() * 20);
      for (Parameter e : p.getParameters().values()) {
         if (e.getValue() != null && !e.getValue().equals(e.getDefault())) {
            sb.append(e.toString()).append("\n");
         }
      }
      return sb.toString();
   }
1022209
def parameter(self):
        '''
        
        '''
        method = self.request.method.lower()
        arguments = self.request.arguments
        files = self.request.files

        rpd = {}  # request parameter dict

        def filter_parameter(key, tp, default=None):
            if tp not in self._types:
                raise ValueError(
                    '%s parameter expected types %s' % (key, self._types))

            if not isinstance(tp, file_types):
                if key not in arguments:
                    rpd[key] = default
                    return

                if tp in [ObjectId, int, float, bool]:
                    rpd[key] = getattr(self, 'to_%s' % getattr(
                        tp, '__name__').lower())(self.get_argument(key))
                    return

                if tp == basestring_type or issubclass(tp, basestring_type):
                    rpd[key] = self.get_argument(key, strip=False)
                    return

                if tp == list:
                    rpd[key] = self.get_arguments(key)
                    return

            if tp == file:
                if key not in files:
                    rpd[key] = []
                    return

                rpd[key] = self.request.files[key]

        required_params = getattr(self, '_required_params', None)
        if isinstance(required_params, list):
            for key, tp, default in required_params:
                filter_parameter(key, tp, default)

        # extract method required params
        method_required_params = getattr(
            self, '_%s_required_params' % method, None)
        if isinstance(method_required_params, list):
            for key, tp, default in method_required_params:
                filter_parameter(key, tp, default)

        params = getattr(self, '_%s_params' % method, None)
        if params is None:
            return rpd

        # need arguments
        try:
            for key, tp in params.get('need', []):
                if tp == list:
                    filter_parameter(key, tp, [])
                else:
                    filter_parameter(key, tp)
        except ValueError as e:
            app_log.error(
                '%s request need arguments parse error: %s' % (method, e))
            raise ValueError(e)
        except Exception as e:
            app_log.error(
                '%s request need arguments parse error: %s' % (method, e))
            raise e

        # option arguments
        for key, tp, default in params.get('option', []):
            filter_parameter(key, tp, default)

        return rpd
638141
def params(self):
        """"""
        par = {"radius": self.radius,
               "sphere_index": self.sphere_index,
               "pha_offset": self.pha_offset,
               "center": [self.posx_offset, self.posy_offset]
               }
        return par
648511
function Param(name,defaults,typ){
	// could have introduced bugs by moving back to identifier here
	this._traversed = false;
	this._name = name;
	this._defaults = defaults;
	this._typ = typ;
	this._variable = null;
}