Variable to be evaluated in computing
        :meth:`ADMMTwoBlockCnstrnt.obfn_g0`, depending on the ``AuxVarObj``
        option value.
506863
def obfn_g0var(self):
        

        return self.var_y0() if self.opt['AuxVarObj'] else \
            self.cnst_A0(self.X) - self.cnst_c0()
262581
def conditional( a, b )
      if a.is_a?( Proc ) and b.is_a?( Proc )
        conditional a.call, b.call
      else
        GCCValue.new @function, "( #{self} ) ? ( #{a} ) : ( #{b} )"
      end
    end
925164
private Variable getVariableAtNode(int index, CallStack callstack) throws UtilEvalError {
        Node nameNode = null;
        if (jjtGetChild(index).jjtGetNumChildren() > 0
                && (nameNode = jjtGetChild(index).jjtGetChild(0))
                    instanceof BSHAmbiguousName)
            return callstack.top().getVariableImpl(
                    ((BSHAmbiguousName) nameNode).text, true);
        return null;
    }
579107
def obfn_g0var(self):
        

        # Use of self.block_sep0(self.AXnr) instead of self.cnst_A0(self.X)
        # reduces number of calls to self.cnst_A0
        return self.var_y0() if self.opt['gEvalY'] else \
            self.block_sep0(self.AXnr)
1326173
def eval_objfn(self):
        

        dfd = self.obfn_g0(self.obfn_g0var())
        cns = self.obfn_g1(self.obfn_g1var())
        return (dfd, cns)
1074036
def obfn_g0(self, Y0):
        
        """

        return np.sum(np.abs(self.W * self.obfn_g0var()))
433819
function substiteVariable(variable, options, cb) {
    var value;
    var err = null;
    var s = variable.split(':', 2);
    if (s.length == 2) {
        value = options.env[s[0]];
        if (typeof value == 'function') {
            value = value();
        }
        if (s[1][0] == '+') {
            // Substitute replacement, but only if variable is defined and nonempty. Otherwise, substitute nothing
            value = value ? s[1].substring(1) : '';
        } else if (s[1][0] == '-') {
            // Substitute the value of variable, but if that is empty or undefined, use default instead
            value = value || s[1].substring(1);
        } else if (s[1][0] == '#') {
            // Substitute with the length of the value of the variable
            value = value !== undefined ? String(value).length : 0;
        } else if (s[1][0] == '=') {
            // Substitute the value of variable, but if that is empty or undefined, use default instead and set the variable to default
            if (!value) {
                value = s[1].substring(1);
                options.env[s[0]] = value;
            }
        } else if (s[1][0] == '?') {
            // If variable is defined and not empty, substitute its value. Otherwise, print message as an error message.
            if (!value) {
                if (s[1].length > 1) {
                    throw new Error();
                    // return cb(s[0] + ': ' + s[1].substring(1));
                } else {
                    throw new Error();
                    // return cb(s[0] + ': parameter null or not set');
                }
            }
        }
    } else {
        value = options.env[variable];
        if (typeof value == 'function') {
            value = value();
        }
    }
    return value;
}
66035
private void associateVariablesWithBlocks() {
        int varRefNo = 0;
        int activeBlockNo = 0;
        int nextBlockNo = 1;
        while (varRefNo < varRefTabCnt) {
            VarRefTabRec vrtr = varRefTab[varRefNo];
            int varRefTPos = vrtr.tPosBegin;
            int varNo = vrtr.varNo;
            if (varRefTPos >= blockTab[activeBlockNo].tPosEnd) {
                activeBlockNo = blockTab[activeBlockNo].parentBlockNo;
                continue;
            }
            if (nextBlockNo < blockTabCnt && varRefTPos >= blockTab[nextBlockNo].tPosBegin) {
                activeBlockNo = nextBlockNo;
                nextBlockNo++;
                continue;
            }
            BlockTabRec btr = blockTab[activeBlockNo];
            if (varRefTPos < btr.tPosBegin) {
                throw new AssertionError();
            }
            int blockVarNo = btr.blockVarCnt++;
            if (btr.blockVarCnt > btr.blockVarNoToVarNoMap.length) {
                btr.blockVarNoToVarNoMap = (int[]) resizeArray(btr.blockVarNoToVarNoMap, 2 * btr.blockVarCnt);
            }
            btr.blockVarNoToVarNoMap[blockVarNo] = varNo;
            if (btr.firstVarRefNo == -1) {
                btr.firstVarRefNo = varRefNo;
            }
            vrtr.blockNo = activeBlockNo;
            vrtr.blockVarNo = blockVarNo;
            varRefNo++;
        }
    }
219258
def get_flag(env, var, fallback, expected=True, warn=True):
    """"""
    val = env.config_var(var)
    if val is None:
        if warn:
            warnings.warn(
                "Config variable '{0}' is unset, Python ABI tag may "
                "be incorrect".format(var),
                RuntimeWarning,
                2,
            )
        return fallback()
    return val == expected
1254805
def obfn_reg(self):
        

        rl1 = np.linalg.norm((self.wl1 * self.obfn_gvar()).ravel(), 1)
        return (self.lmbda*rl1, rl1)
288870
function checkVariable(i) {
  const start = i;
  let l;

  if (i >= tokensLength) return 0;

  // Skip `$`.
  if (tokens[i].type === TokenType.DollarSign) i++;
  else return 0;

  if (l = checkIdent(i)) i += l;
  else return 0;

  return i - start;
}
662644
def eval_objfn(self):
        

        g0v = self.obfn_g0(self.obfn_g0var())
        g1v = self.obfn_g1(self.obfn_g1var())
        rgr = sl.rfl2norm2(np.sqrt(self.GHGf * np.conj(self.Xf) * self.Xf),
                           self.cri.Nv, self.cri.axisN)/2.0
        obj = g0v + self.lmbda*g1v + self.mu*rgr
        return (obj, g0v, g1v, rgr)
225101
def obfn_g0(self, Y0):
        
        """

        return np.linalg.norm(sp.proj_l2(Y0, self.epsilon,
                                         axis=self.cri.axisN) - Y0)
285392
public void setBlockVariable( String name, Object value )
        throws UtilEvalError
    {
        super.setVariable( name, value, false/*strict?*/, false );
    }
667472
def __set_target_variables_aux (manager, rule_or_module, ps):
    
    assert isinstance(rule_or_module, basestring)
    assert isinstance(ps, property_set.PropertySet)
    result = []

    for f in __flags.get(rule_or_module, []):

        if not f.condition or find_satisfied_condition (f.condition, ps):
            processed = []
            for v in f.values:
                # The value might be <feature-name> so needs special
                # treatment.
                processed += __handle_flag_value (manager, v, ps)

            for r in processed:
                result.append ((f.variable_name, r))

    # strip away last dot separated part and recurse.
    next = __re_split_last_segment.match(rule_or_module)

    if next:
        result.extend(__set_target_variables_aux(
            manager, next.group(1), ps))

    return result
407672
def eval_objfn(self):
        

        fval = self.obfn_f(self.X)
        gval = self.obfn_g(self.X)
        obj = fval + gval
        return (obj, fval, gval)
656853
def _get_value(self, variable):
        """"""
        return swiglpk.glp_mip_col_val(
            self._problem._p, self._problem._variables[variable])