Initialize a two-dimensional array of size m by m.
    
        :ivar int m: A value for m.
760907
def createBinaryRelation(self, m):
        

        binaryRelation = []
        for i in range(m):
            binaryRelation.append(range(m))
            binaryRelation[i][i] = 0
        return binaryRelation
171356
def to_java_ints(m):
    '''
    
    '''
    global _java
    if _java is None: _init_registration()
    m = np.asarray(m)
    dims = len(m.shape)
    if dims > 2: raise ValueError('1D and 2D arrays supported only')
    bindat = serialize_numpy(m, 'i')
    return (_java.jvm.nben.util.Numpy.int2FromBytes(bindat) if dims == 2
            else _java.jvm.nben.util.Numpy.int1FromBytes(bindat))
1124767
function setValueM2a( gl, v ) {

	var cache = this.cache;
	var data = flatten( v, this.size, 4 );

	if ( arraysEqual( cache, data ) ) return;

	gl.uniformMatrix2fv( this.addr, false, data );

	this.updateCache( data );

}
1268934
private Node[][][] initialLattice(Instance inst) {
		int[][][] data = (int[][][]) inst.getData();
		length = inst.length();

		Node[][][] lattice = new Node[2][length][];
		for (int i = 0; i < length; i++) {
			lattice[0][i] = new Node[ysize[0]];
			for (int j = 0; j < ysize[0]; j++) {
				lattice[0][i][j] = new Node(ysize[0], ysize[1]);
			}
			initialClique(lattice[0][i], data[0][i], orders[0], ysize[0],
					ysize[1]);

			lattice[1][i] = new Node[ysize[1]];
			for (int j = 0; j < ysize[1]; j++) {
				lattice[1][i][j] = new Node(ysize[1], ysize[0]);
			}
			initialClique(lattice[1][i], data[1][i], orders[1], ysize[1],
					ysize[0]);
		}

		return lattice;
	}
931500
function init(version) {
    var N = version * 4 + 17;
    var matrix = [];
    var zeros = new Buffer(N);
    zeros.fill(0);
    zeros = [].slice.call(zeros);
    for (var i = 0; i < N; i++) {
        matrix[i] = zeros.slice();
    }
    return matrix;
}
529589
private void initialize(ReadOnlyVector3 a, ReadOnlyVector3 b, ReadOnlyVector3 c ) 
    {
        final int verts = 3;
        _meshData.setVertexBuffer(BufferUtils.createVector3Buffer(3));
        _meshData.setNormalBuffer(BufferUtils.createVector3Buffer(3));
        final FloatBuffer tbuf = BufferUtils.createVector2Buffer(3);
        _meshData.setTextureBuffer(tbuf, 0);

        _meshData.setIndexBuffer(BufferUtils.createIntBuffer(3));

        Vector3 ba = Vector3.fetchTempInstance();
        Vector3 ca = Vector3.fetchTempInstance();
        ba.set( b ).subtractLocal( a );
        ca.set( c ).subtractLocal( a );
        ba.crossLocal( ca ).normalizeLocal();
        
        _meshData.getNormalBuffer().put(ba.getXf()).put(ba.getYf()).put(ba.getZf());
        _meshData.getNormalBuffer().put(ba.getXf()).put(ba.getYf()).put(ba.getZf());
        _meshData.getNormalBuffer().put(ba.getXf()).put(ba.getYf()).put(ba.getZf());

        Vector3.releaseTempInstance( ba );
        Vector3.releaseTempInstance( ca );
        
        tbuf.put(0).put(1);
        tbuf.put(0).put(0);
        tbuf.put(1).put(0);

        _meshData.getIndexBuffer().put(0);
        _meshData.getIndexBuffer().put(1);
        _meshData.getIndexBuffer().put(2);

        _meshData.getVertexBuffer().put(a.getXf()).put(a.getYf()).put(a.getZf());
        _meshData.getVertexBuffer().put(b.getXf()).put(b.getYf()).put(b.getZf());
        _meshData.getVertexBuffer().put(c.getXf()).put(c.getYf()).put(c.getZf());
    }
279245
def init_with_ary(ary)
      @tuple = Array.new(ary.size)
      @tuple.size.times do |i|
        @tuple[i] = ary[i]
      end
    end
742306
private void initialize(int bytes) {
		Preconditions.checkArgument(bytes > 0, "Requested array with zero capacity");
		Preconditions.checkArgument(bytes <= MAX_ARRAY_SIZE, "Requested capacity exceeds limit of " + MAX_ARRAY_SIZE);

		data = new byte[bytes];
	}
29686
function createWithDimensions(dims, val){
    if(!Array.isArray(dims)) throw new Error("dims must be an array.");
    if(undef(val)) throw new Error("val must be defined.");
    
    const l = dims[dims.length - 1];
    const nextDims = dims.slice(0, -1);
    const array = new Array(l).fill(val);

    if(nextDims.length === 0) return new Vector(array);
    return createWithDimensions(nextDims, array);
}
829618
def _init_a(D):
    ''''''
    E = D.mean(axis=0)
    E2 = (D**2).mean(axis=0)
    return ((E[0] - E2[0])/(E2[0]-E[0]**2)) * E
446572
private int setSecDataArr(HashMap m, ArrayList arr) {

        if (!m.isEmpty()) {
            for (int j = 0; j < arr.size(); j++) {
                if (arr.get(j).equals(m)) {
                    return j + 1;
                }
            }
            arr.add(m);
            return arr.size();
        } else {
            return 0;
        }
    }
1148876
public MatrixSize readArraySize() throws IOException {
        int numRows = getInt(), numColumns = getInt();

        return new MatrixSize(numRows, numColumns, numRows * numColumns);
    }
1001235
public void initializeSeqVec(int vectorLength, int numWords, long seed, int columnsPerShard, boolean useHs,
                    boolean useNegSampling) {
        InitializationRequestMessage dim = new InitializationRequestMessage(vectorLength, numWords, seed, useHs,
                        useNegSampling, columnsPerShard);
        transport.sendMessage(dim);
    }
1373023
function _Matrix4x4(data) {
  Matrix.apply(this, [4, 4, data]);

  for(var i=0; i<4; i++)
    for(var j=0; j<4; j++)
      readonly(this, "m" + (i+1) + (j+1), this.values[4 * i + j]);
}
862174
def initialize(
            self, M_c, M_r, T, seed, initialization=b'from_the_prior',
            row_initialization=-1, n_chains=1,
            ROW_CRP_ALPHA_GRID=(), COLUMN_CRP_ALPHA_GRID=(),
            S_GRID=(), MU_GRID=(), N_GRID=31,):
        
        # FIXME: why is M_r passed?
        arg_tuples = self.get_initialize_arg_tuples(
            M_c, M_r, T, initialization, row_initialization, n_chains,
            ROW_CRP_ALPHA_GRID, COLUMN_CRP_ALPHA_GRID, S_GRID, MU_GRID, N_GRID,
            make_get_next_seed(seed),)

        chain_tuples = self.mapper(self.do_initialize, arg_tuples)
        X_L_list, X_D_list = zip(*chain_tuples)
        if n_chains == 1:
            X_L_list, X_D_list = X_L_list[0], X_D_list[0]

        return X_L_list, X_D_list
844565
protected static <O> void initializeMatrices(MatrixParadigm mat, ArrayModifiableDBIDs prots, DistanceQuery<O> dq) {
    final DBIDArrayIter ix = mat.ix, iy = mat.iy;
    final double[] distances = mat.matrix;
    int pos = 0;
    for(ix.seek(0); ix.valid(); ix.advance()) {
      for(iy.seek(0); iy.getOffset() < ix.getOffset(); iy.advance()) {
        distances[pos] = dq.distance(ix, iy);
        prots.add(iy);
        pos++;
      }
    }
    assert (prots.size() == pos);
  }
1369305
protected void init(DMatrixRMaj A ) {
        UBV = A;

        m = UBV.numRows;
        n = UBV.numCols;

        min = Math.min(m,n);
        int max = Math.max(m,n);

        if( b.length < max+1 ) {
            b = new double[ max+1 ];
            u = new double[ max+1 ];
        }
        if( gammasU.length < m ) {
            gammasU = new double[ m ];
        }
        if( gammasV.length < n ) {
            gammasV = new double[ n ];
        }
    }