Return initialiser for working variable U
188563
def uinit(self, ushape):
        """"""

        if self.opt['Y0'] is None:
            return np.zeros(ushape, dtype=self.dtype)
        else:
            # If initial Y is non-zero, initial U is chosen so that
            # the relevant dual optimality criterion (see (3.10) in
            # boyd-2010-distributed) is satisfied.
            Ub0 = (self.W**2) * self.block_sep0(self.Y) / self.rho
            Ub1 = self.block_sep1(self.Y)
            return self.block_cat(Ub0, Ub1)
656942
def set_U1U2(self, U1, U2):
        
        if len(np.shape(U1)) == 0:
          U1 = U1 * np.ones((self.ny)) 
        if len(np.shape(U2)) == 0:
          U2 = U2 * np.ones((self.ny)) 
        #self.Ubg = np.array([U1,U2])[:,np.newaxis,np.newaxis]
        self.U1 = U1
        self.U2 = U2
        self.Ubg = np.array([U1,U2])
1329525
def __init_go2nt_w_usr(self, gos_all, usr_go2nt, prt_flds_all):
        """"""
        assert usr_go2nt, "go2nt HAS NO ELEMENTS"
        from goatools.nt_utils import get_unique_fields
        go2nts = [usr_go2nt, self.gosubdag.go2nt, self._get_go2nthdridx(gos_all)]
        usr_nt_flds = next(iter(usr_go2nt.values()))._fields # Get any single value from a dict
        flds = get_unique_fields([usr_nt_flds, prt_flds_all])
        go2nt = get_dict_w_id2nts(gos_all, go2nts, flds)
        return self._init_go2nt_aug(go2nt)
952514
def get_init(self):
        
        suffix = self._separator + "%s" % str(self._counter_init)

        return self._base_name + suffix
89927
Object getu( String name ) {
        try {
            return get( name );
        } catch ( EvalError e ) {
            throw new InterpreterError("set: "+e, e);
        }
    }
845396
def initCTR(self, iv=0):
        """"""
        assert struct.calcsize("Q") == self.blocksize()
        self.ctr_iv = iv
        self._calcCTRBUF()
376824
def u8(self, name, value=None, align=None):
        """"""
        self.uint(1, name, value, align)
622900
def get_uuid(obj):
    """"""
    # TODO: deprecate null uuid ret val
    from uuid import UUID
    try:
        uuid = obj.attrs['uuid']
    except KeyError:
        return UUID(int=0)
    # convert to unicode for python 3
    try:
        uuid = uuid.decode('ascii')
    except (LookupError, AttributeError):
        pass
    return UUID(uuid)
1259803
def get_in_property(value, is_bytes=False):
    """"""

    if value.startswith('^'):
        prefix = value[1:3]
        temp = value[3:]
        negate = '^'
    else:
        prefix = value[:2]
        temp = value[2:]
        negate = ''

    if prefix != 'in':
        raise ValueError("Does not start with 'in'!")

    value = negate + unidata.unicode_alias['block'].get(temp, temp)
    obj = unidata.ascii_blocks if is_bytes else unidata.unicode_blocks

    return obj[value]
4329
function initVar (key, envKey, def) {
        var negate = !def;
        switch (true) {
            case cacheObj.hasOwnProperty(key):
                return cacheObj[key];
            case process.env.hasOwnProperty(envGlobalCacheKey):
                return process.env[envGlobalCacheKey] !== '';
            case process.env.hasOwnProperty(envKey):
                return negate ? process.env[envKey] === 'YES' : process.env[envKey] !== 'NO';
            default:
                return def;
        }
    }
506548
def u_string_check(self, original, loc, tokens):
        """"""
        return self.check_strict("Python-2-style unicode string", original, loc, tokens)
265138
function declarationImpliesInitialisation(variable, scope) {
  return variable.name === "arguments" && scope.type === ScopeType.FUNCTION ||
    variable.declarations.some(decl =>
      decl.type === DeclarationType.PARAMETER ||
      decl.type === DeclarationType.FUNCTION_NAME ||
      decl.type === DeclarationType.CATCH
    );
}
1327744
def _init_worker(X, X_shape, X_dtype):
    """"""
    # Using a dictionary is not strictly necessary. You can also
    # use global variables.
    mprotate_dict["X"] = X
    mprotate_dict["X_shape"] = X_shape
    mprotate_dict["X_dtype"] = X_dtype
629393
def initial_state(self, batch_size, dtype=tf.float32, trainable=False,
                    trainable_initializers=None, trainable_regularizers=None,
                    name=None):
    """"""
    return self._core.initial_state(
        batch_size, dtype=dtype, trainable=trainable,
        trainable_initializers=trainable_initializers,
        trainable_regularizers=trainable_regularizers, name=name)
875324
function getInstanceInitExpression(initInstanceVars) {
  let expressions = initInstanceVars.map((mv) => {
    let name = mv.name.literalToken;
    return parseExpression `this.${name} = ${mv.initializer}`;
  });
  return createCommaExpression(expressions);
}
190852
function U64(hi, lo) {
  if (!(this instanceof U64))
    return new U64(hi, lo);

  this.hi = hi | 0;
  this.lo = lo | 0;
}
56348
def _init_uninit_vars(self):
        
        uninit_vars = self.sess.run(tf.report_uninitialized_variables())
        vars_list = list()
        for v in uninit_vars:
            var = v.decode("utf-8")
            vars_list.append(var)
        uninit_vars_tf = [v for v in tf.global_variables() if v.name.split(':')[0] in vars_list]
        self.sess.run(tf.variables_initializer(var_list=uninit_vars_tf))