Tiny set for testing.
770919
def rlmb_ppo_tiny():
  """"""
  hparams = rlmb_ppo_base()
  hparams = hparams.override_from_dict(_rlmb_tiny_overrides())
  update_hparams(hparams, dict(
      ppo_epochs_num=2,
      ppo_epoch_length=10,
      real_ppo_epoch_length=36,
      real_ppo_effective_num_agents=2,
      real_batch_size=1,
      eval_batch_size=1,
  ))
  return hparams
352318
void or(LongBitSet other) {
		assert other.numWords <= numWords : "numWords=" + numWords + ", other.numWords=" + other.numWords;
		int pos = Math.min(numWords, other.numWords);
		while (--pos >= 0) {
			bits[pos] |= other.bits[pos];
		}
	}
878857
def size(ctx, dataset, kwargs):
    ""

    kwargs = parse_kwargs(kwargs)
    (print)(data(dataset, **ctx.obj).get(**kwargs).complete_set.size)
665788
def reset_small(self, eq):
        """"""
        assert eq in ('f', 'g')
        for idx, var in enumerate(self.__dict__[eq]):
            if abs(var) <= 1e-12:
                self.__dict__[eq][idx] = 0
1227541
function (big, small) {
                var isBigArray = typeUtils.isArray(big), isBigObject = typeUtils.isObject(big), isSmallArray = typeUtils.isArray(small), isSmallObject = typeUtils.isObject(small);

                if (isBigArray && isSmallArray) {
                    for (var i = 0, l = small.length; i < l; i++) {
                        if (!this.contains(big[i], small[i])) {
                            return false;
                        }
                    }
                } else if (isBigObject && isSmallObject) {
                    for (var key in small) {
                        if (small.hasOwnProperty(key)) {
                            if (key.match(/:/)) {
                                continue; // meta-data: we don't copy them
                            }
                            if (small.hasOwnProperty(key)) {
                                if (!this.contains(big[key], small[key])) {
                                    return false;
                                }
                            }
                        }
                    }
                } else {
                    var allTime = (typeUtils.isDate(big) && typeUtils.isDate(small));
                    if (allTime) {
                        return (small.getTime() === big.getTime());
                    } else {
                        return small === big;
                    }
                }
                return true;
            }
1094208
void printSet(Collection<RBBINode> s) {
           for (RBBINode n : s) {
               RBBINode.printInt(n.fSerialNum, 8);
           }
           System.out.println();
       }
391712
static void countHetero(List<IRingSet> rsets) {
        for (IRingSet rset : rsets) {
            int numHeteroAtoms = 0;
            int numHeteroRings = 0;
            for (IAtomContainer ring : rset.atomContainers()) {
                int prevNumHeteroAtoms = numHeteroAtoms;
                for (IAtom atom : ring.atoms()) {
                    Integer elem = atom.getAtomicNumber();
                    if (elem != null && elem != 6 && elem != 1)
                        numHeteroAtoms++;
                }
                if (numHeteroAtoms > prevNumHeteroAtoms)
                    numHeteroRings++;
            }
            rset.setProperty(NUM_HETERO_ATOMS, numHeteroAtoms);
            rset.setProperty(NUM_HETERO_RINGS, numHeteroRings);
        }
    }
978801
@Override
  public Short set(int index, Short element) {
    return set(index, element.shortValue());
  }
365489
def mtf_bitransformer_tiny():
  """"""
  hparams = mtf_bitransformer_base()
  hparams.batch_size = 2
  hparams.mesh_shape = ""
  hparams.d_model = 128
  hparams.encoder_layers = ["self_att", "drd"] * 2
  hparams.decoder_layers = ["self_att", "enc_att", "drd"] * 2
  hparams.num_heads = 4
  hparams.d_ff = 512
  return hparams
768485
function (test) {
                const bits = QRUtil.getBCHTypeNumber(_typeNumber);

                for (var i = 0; i < 18; i += 1) {
                    var mod = (!test && ((bits >> i) & 1) == 1);
                    /** @type {(boolean|null)[][]} */
                    (_modules)[Math.floor(i / 3)][i % 3 + _moduleCount - 8 - 3] = mod;
                }

                for (var i = 0; i < 18; i += 1) {
                    var mod = (!test && ((bits >> i) & 1) == 1);
                    /** @type {(boolean|null)[][]} */
                    (_modules)[i % 3 + _moduleCount - 8 - 3][Math.floor(i / 3)] = mod;
                }
            }
19873
def measure_string(self, text, fontname, fontsize, encoding=0):
        """"""
        return _fitz.Tools_measure_string(self, text, fontname, fontsize, encoding)
1202486
function lset(index, value) {
  if(index < 0) index = this._data.length + index;
  // command should validate the index
  if(index < 0 || index >= this._data.length) return null;
  this._data[index] = value;
}
330734
private static final int mula_small(byte[] p,byte[] q,int m,byte[] x,int n,int z) {
		int v=0;
		for (int i=0;i<n;++i) {
			v+=(q[i+m] & 0xFF)+z*(x[i] & 0xFF);
			p[i+m]=(byte)v;
			v>>=8;
		}
		return v;		
	}
773225
def measure(config)
      reduce(MeasurementSet.new) do |set, document|
        set.merge(Document.measure(document, config))
      end
    end
1111737
def _get_sampleset(model):
    """"""
    if isinstance(model, Model):
        if hasattr(model, 'sampleset'):
            w = model.sampleset()
        else:
            w = None
    else:
        w = model  # Already a sampleset
    return w
1354994
def run_toy_SGLD(gpu_id=None):
    """"""
    X, Y, X_test, Y_test = load_toy()
    minibatch_size = 1
    teacher_noise_precision = 1.0 / 9.0
    net = get_toy_sym(True, teacher_noise_precision)
    data_shape = (minibatch_size,) + X.shape[1::]
    data_inputs = {'data': nd.zeros(data_shape, ctx=dev(gpu_id)),
                   'teacher_output_label': nd.zeros((minibatch_size, 1), ctx=dev(gpu_id))}
    initializer = mx.init.Uniform(0.07)
    exe, params, _ = SGLD(sym=net,
                          data_inputs=data_inputs,
                          X=X,
                          Y=Y,
                          X_test=X_test,
                          Y_test=Y_test,
                          total_iter_num=50000,
                          initializer=initializer,
                          learning_rate=1E-4,
                          # lr_scheduler=mx.lr_scheduler.FactorScheduler(100000, 0.5),
                          prior_precision=0.1,
                          burn_in_iter_num=1000,
                          thin_interval=10,
                          task='regression',
                          minibatch_size=minibatch_size,
                          dev=dev(gpu_id))
739152
function tinyBars (str, data) {
  var re = /\{\{(.+)\}\}/gi
  return str.replace(re, function (match, val) {
    return data[val.trim()] || ''
  })
}