Add one more variable as an input of the block

        :param variable: variable (or signal as it is also a variable)
167211
def _AddInput(self, variable):
        
        if isinstance(variable, Variable):
            self.inputs.append(variable)
        else:
            print('Error: ', variable.name, variable,
                  ' given is not a variable')
            raise TypeError
153111
def add_variables(vars)
      objective_buffer = build_pointer_array vars.map(&:coefficient), :double
      lb_buffer = build_pointer_array vars.map(&:lower_bound), :double
      ub_buffer = build_pointer_array vars.map(&:upper_bound), :double
      type_buffer = build_pointer_array(vars.map do |var|
        gurobi_type(var.type)
      end, :char)
      names_buffer = build_pointer_array array_to_pointers_to_names(vars),
                                         :pointer

      ret = Gurobi.GRBaddvars @ptr, vars.length, 0, nil, nil, nil,
                              objective_buffer, lb_buffer, ub_buffer,
                              type_buffer, names_buffer

      fail if ret != 0

      # Store all the variables in the model
      vars.each { |var| store_variable var }

      # Update the model with variables so constraint adds succeed
      ret = Gurobi.GRBupdatemodel @ptr
      fail if ret != 0
    end
1023743
def _add_var(var, value):
    '''
    
    '''
    makeconf = _get_makeconf()
    layman = 'source /var/lib/layman/make.conf'
    fullvar = '{0}="{1}"'.format(var, value)
    if __salt__['file.contains'](makeconf, layman):
        # TODO perhaps make this a function in the file module?
        cmd = ['sed', '-i', r'/{0}/ i\{1}'.format(
                    layman.replace('/', '\\/'),
                    fullvar),
               makeconf]
        __salt__['cmd.run'](cmd)
    else:
        __salt__['file.append'](makeconf, fullvar)
618135
def add_input_variable(self, var):
        """"""
        assert(isinstance(var, Variable))
        self.input_variable_list.append(var)
459683
def _variable(lexer):
    """"""
    names = _names(lexer)

    tok = next(lexer)
    # NAMES '[' ... ']'
    if isinstance(tok, LBRACK):
        indices = _indices(lexer)
        _expect_token(lexer, {RBRACK})
    # NAMES
    else:
        lexer.unpop_token(tok)
        indices = tuple()

    return ('var', names, indices)
40550
def __add_variables(self, *args, **kwargs):
        

        for variable in args:
            self.__variables[variable] = None
        self.__variables.update(kwargs)
972424
def register_feature(self, var):
        
        if var in self._features or var in self.STATIC_FEATURES:
            raise ValueError("feature already claimed: {!r}".format(var))
        self._features.add(var)
        self.on_info_changed()
1270691
def prepend_path_variable_command(variable, paths):
    
    assert isinstance(variable, basestring)
    assert is_iterable_typed(paths, basestring)
    return path_variable_setting_command(
        variable, paths + [expand_variable(variable)])
1090590
public static function addVar($msg, $var)
	{
		if(self::$debug)
		{
			self::$debugData .= self::makePrintable($msg) . ": " .
				self::makePrintable(print_r($var, true)) . "\n";
		}
	}
787793
private String addAndEncodeVariable(String originalValue, String newVariable,
      String newVariableName, boolean encode) {
    return addAndEncode(originalValue, newVariable, newVariableName, encode);
  }
927474
def add_chain(self, var):
        
        chain = FunctionChain(var, [])
        self._chains[var] = chain
        self[var] = chain
411027
def simple_input(self, variables):
        
        json_args = fill_template_str(json.dumps(self.data), variables)
        return try_get_objects(json_args)
414850
def _add_variable(self, variable):
        
        # TODO: Add feature for accepting additional properties of states.
        variable_data = self.data['probnet']['Variables'][variable]
        variable_element = etree.SubElement(self.variables, 'Variable', attrib={'name': variable,
                                                                                'type': variable_data['type'],
                                                                                'role': variable_data['role']})

        try:
            etree.SubElement(variable_element, 'Comment').text = variable_data['Comment']
        except KeyError:
            pass
        try:
            etree.SubElement(variable_element, 'Coordinates', variable_data['Coordinates'])
        except KeyError:
            pass

        try:
            for key, value in sorted(variable_data['AdditionalProperties'].items()):
                etree.SubElement(variable_element, 'Property', attrib={'name': key, 'value': value})
        except KeyError:
            etree.SubElement(variable_element, 'AdditionalProperties')
        states = etree.SubElement(variable_element, 'States')
        for s in sorted(variable_data['States']):
            state = etree.SubElement(states, 'State', attrib={'name': s})
            try:
                self._add_additional_properties(state, variable_data['States'][s]['AdditionalProperties'])
            except KeyError:
                etree.SubElement(state, 'AdditionalProperties')
529321
function() {
    this.setHelpUrl(Blockly.Msg.VARIABLES_GET_HELPURL);
    this.setColour(Blockly.Blocks.variables.HUE);
    this.appendDummyInput()
        .appendField(new Blockly.FieldVariable(
        Blockly.Msg.VARIABLES_DEFAULT_NAME), 'VAR');
    this.setOutput(true);
    this.setTooltip(Blockly.Msg.VARIABLES_GET_TOOLTIP);
    this.contextMenuMsg_ = Blockly.Msg.VARIABLES_GET_CREATE_SET;
  }
994567
def set(self, variables: Dict[str, str]):
        
        current_variables = self.get()
        difference = DictDiffer(variables, current_variables)

        removed_keys = difference.removed()
        self.remove(removed_keys)

        changed_keys = difference.added() | difference.changed()
        changed = {key: variables[key] for key in changed_keys}
        self.add(changed, overwrite=True)
478396
function addVariable() {
            variableService.addOrUpdate(vm.variable, function () {
                vm.variables[vm.variable.key] = vm.variable.value;
                vm.variable = {
                    key: undefined,
                    value: undefined
                };
            });
        }
1370160
def addVar(self, sig: object, name: str, sigType: VCD_SIG_TYPE, width: int,
               valueFormatter: Callable[["Value"], str]):
        
        vInf = self._writer._idScope.registerVariable(sig, name, self, width,
                                                      sigType, valueFormatter)
        self.children[vInf.name] = vInf
        self._writer._oFile.write("$var %s %d %s %s $end\n" % (
            sigType, vInf.width, vInf.vcdId, vInf.name))