Description:
            Full breaking
        Parameters:
            k: not used
545758
def _full(self, k):
        
        G = np.ones((self.m, self.m))
        #np.fill_diagonal(G, 0) # erroneous code from prefpy
        return G
687482
def _truncate(self, x, k):
        '''  '''
        not_F = np.argsort(np.abs(x))[:-k]
        x[not_F] = 0
        return x
177120
private void del(int k)
	{
		//if(last < 0)    last = sapp[-1] -= (k);
		//else            last = *sapp++ = -(k);

		if(last < 0)    last = sapp[sappPos-1]   -=  (k);
		else            last = sapp[(sappPos++)]  = -(k);
	}
363780
function mk_LiteralBunch(k_graph, a_terms) {
	// append local methods to hash
	let h_methods = Object.assign(Object.create(LiteralBunch_prototype), {
		graph: k_graph,
		terms: a_terms,

		// for returning a different sample each time
		sample_counter: 0,
	});

	// construct 'that'
	let f_bound = LiteralBunch_operator.bind(h_methods);

	// make & return operator
	Object.setPrototypeOf(f_bound, LiteralBunch_prototype);
	return Object.assign(f_bound, h_methods);
}
380167
def _get_k(self):
        '''
        
        '''
        if not self.ready:
            self.k.create() # create table if it does not exist.
            self.ready = True

        return self.k
768658
def topk(arg, k, by=None):
    
    op = ops.TopK(arg, k, by=by)
    return op.to_expr()
1330488
def xception(c, k=8, n_middle=8):
    ""
    layers = [
        conv(3, k*4, 3, 2),
        conv(k*4, k*8, 3),
        ConvSkip(k*8, k*16, act=False),
        ConvSkip(k*16, k*32),
        ConvSkip(k*32, k*91),
    ]
    for i in range(n_middle): layers.append(middle_flow(k*91))
    layers += [
        ConvSkip(k*91,k*128),
        sep_conv(k*128,k*192,act=False),
        sep_conv(k*192,k*256),
        nn.ReLU(),
        nn.AdaptiveAvgPool2d(1),
        Flatten(),
        nn.Linear(k*256,c)
    ]
    return nn.Sequential(*layers)
699166
public V remove(K key) throws Exception {
        return invoke(REMOVE, key, null, true);
    }
825033
def setKUS(self, K, U, S):
        
        return _core.CLMM_setKUS(self, K, U, S)
1181308
@Override
    @SuppressWarnings("unchecked")
    protected void fixup(int k) {
        if (onMinLevel(k)) {
            int p = k / 2;
            K kValue = array[k];
            if (p > 0 && ((Comparable<? super K>) array[p]).compareTo(kValue) < 0) {
                array[k] = array[p];
                array[p] = kValue;
                fixupMax(p);
            } else {
                fixupMin(k);
            }
        } else {
            int p = k / 2;
            K kValue = array[k];
            if (p > 0 && ((Comparable<? super K>) kValue).compareTo(array[p]) < 0) {
                array[k] = array[p];
                array[p] = kValue;
                fixupMin(p);
            } else {
                fixupMax(k);
            }
        }
    }
64165
def []= k, v   
      split_fields if not @h
      kupper = k.upcase
      @h[kupper] = v
      @original_key[kupper] = k
    end
838247
private void fixupMaxWithComparator(int k) {
        K key = array[k];
        int gp = k / 4;
        while (gp > 0 && comparator.compare(array[gp], key) < 0) {
            array[k] = array[gp];
            k = gp;
            gp = k / 4;
        }
        array[k] = key;
    }
697755
def parse_kv(args):
    '''  '''

    options = {}
    if args is not None:
        # attempting to split a unicode here does bad things
        vargs = shlex.split(str(args), posix=True)
        for x in vargs:
            if x.find("=") != -1:
                k, v = x.split("=",1)
                options[k]=v
    return options
568306
def K(self):
        
        try:
            return self._kernel
        except AttributeError:
            self._kernel = self._build_kernel()
            return self._kernel
402008
def free(self, *args, **kwargs):
        
        # first set all the keyword argument values
        self.set(**kwargs)

        # get everything into one big list
        cnames = list(args) + list(kwargs.keys())

        # move each pname to the constants
        for cname in cnames:

            if not cname in self._cnames:
                self._error("Naughty. '"+cname+"' is not a valid constant name.")

            else:
                n = self._cnames.index(cname)

                # make the switcheroo
                if type(self._pnames)    is not list: self._pnames    = list(self._pnames)
                if type(self._pguess)    is not list: self._pguess    = list(self._pguess)
                if type(self._cnames)    is not list: self._cnames    = list(self._cnames)
                if type(self._constants) is not list: self._constants = list(self._constants)
                self._pnames.append(self._cnames.pop(n))
                self._pguess.append(self._constants.pop(n))

                # update
                self._update_functions()

        return self
1063523
def _kde_support(bin_range, bw, gridsize, cut, clip):
    """"""
    kmin, kmax = bin_range[0] - bw * cut, bin_range[1] + bw * cut
    if isfinite(clip[0]):
        kmin = max(kmin, clip[0])
    if isfinite(clip[1]):
        kmax = min(kmax, clip[1])
    return np.linspace(kmin, kmax, gridsize)
941612
async function kdf(hash_algo, X, length, param, stripLeading=false, stripTrailing=false) {
  // Note: X is little endian for Curve25519, big-endian for all others.
  // This is not ideal, but the RFC's are unclear
  // https://tools.ietf.org/html/draft-ietf-openpgp-rfc4880bis-02#appendix-B
  let i;
  if (stripLeading) {
    // Work around old go crypto bug
    for (i = 0; i < X.length && X[i] === 0; i++);
    X = X.subarray(i);
  }
  if (stripTrailing) {
    // Work around old OpenPGP.js bug
    for (i = X.length - 1; i >= 0 && X[i] === 0; i--);
    X = X.subarray(0, i + 1);
  }
  const digest = await hash.digest(hash_algo, util.concatUint8Array([
    new Uint8Array([0, 0, 0, 1]),
    X,
    param
  ]));
  return digest.subarray(0, length);
}