Set the values at (row, col) to val in Jacobian m

        :param m: Jacobian name
        :param val: values to set
        :param row: row indices
        :param col: col indices
        :return: None
511468
def set_jac(self, m, val, row, col):
        
        assert m in ('Fx', 'Fy', 'Gx', 'Gy', 'Fx0', 'Fy0', 'Gx0', 'Gy0'), \
            'Wrong Jacobian matrix name <{0}>'.format(m)

        if isinstance(val,
                      (int, float)) and isinstance(row,
                                                   (np.ndarray, matrix, list)):
            val = val * ones(len(row), 1)

        self._set[m]['I'] = matrix([self._set[m]['I'], matrix(row)])
        self._set[m]['J'] = matrix([self._set[m]['J'], matrix(col)])
        self._set[m]['V'] = matrix([self._set[m]['V'], matrix(val)])
635496
public void setColumn (int col, Vector3 v) {
        setColumn(col, v.x(), v.y(), v.z());
    }
1305492
public void assign(double val) {
	for (int i = 0; i < rows; i++) {
	    for (int j = 0; j < cols; j++) {
		mtrx[i][j] = val;
	    }
	}
    }
790394
def set_row(self, index, values):
        
        if self._sort:
            exists, i = sorted_exists(self._index, index)
            if not exists:
                self._insert_row(i, index)
        else:
            try:
                i = self._index.index(index)
            except ValueError:  # new row
                i = len(self._index)
                self._add_row(index)
        if isinstance(values, dict):
            if not (set(values.keys()).issubset(self._columns)):
                raise ValueError('keys of values are not all in existing columns')
            for c, column in enumerate(self._columns):
                self._data[c][i] = values.get(column, self._data[c][i])
        else:
            raise TypeError('cannot handle values of this type.')
1125824
public static void multRows(double[] values, DMatrixRMaj A) {
        if( values.length < A.numRows ) {
            throw new IllegalArgumentException("Not enough elements in values.");
        }

        int index = 0;
        for (int row = 0; row < A.numRows; row++) {
            double v = values[row];
            for (int col = 0; col < A.numCols; col++, index++) {
                A.data[index] *= v;
            }
        }
    }
849454
def SetColumnValues(self, col, value):
        
        try:
            self.dataframe.iloc[:, col] = value
        except ValueError:
            self.dataframe.loc[:, col] = value
1240852
public static void byRow(Matrix m) {
        for (int i = 0; i < m.rows(); ++i) {
            double rowSum = 0;
            for (int j = 0; j < m.columns(); ++j)
                rowSum += m.get(i,j);

            // Skip row whose sume is zero.
            if (rowSum == 0) 
                continue;
            for (int j = 0; j < m.columns(); ++j)
                m.set(i,j, m.get(i,j) / rowSum);
        }
    }
106925
function set( $row, $col, $value )
    {
        if ( $value !== 0 )
        {
            $pos = $row * $this->Cols + $col;
            $pos = base_convert( $pos, 10, 36 );
            $this->Matrix["*$pos"] = $value;
        }
    }
1176582
def set_values(self,x):
        

        x = numpy.atleast_2d(x)

        x = x.real # ahem

        C_inv = self.__C_inv__
        theta = numpy.dot( x, C_inv )
        self.theta = theta

        return theta
680417
public void setRow(RowVector rv, int r) throws MatrixException
    {
        if ((r < 0) || (r >= nRows)) {
            throw new MatrixException(MatrixException.INVALID_INDEX);
        }
        if (nCols != rv.nCols) {
            throw new MatrixException(
                                MatrixException.INVALID_DIMENSIONS);
        }

        for (int c = 0; c < nCols; ++c) {
            this.values[r][c] = rv.values[0][c];
        }
    }
561831
def _setVal(self, name, val, defVal = None):
        """"""
        if val == defVal:
            return
        if not hasattr(self, "vals"):
            self.vals = {}
        self.vals[name] = val
180488
def set_attr(self, name: str, values: np.ndarray, axis: int = 0, dtype: str = None) -> None:
		
		deprecated("'set_attr' is deprecated. Use 'ds.ra.key = values' or 'ds.ca.key = values' instead")
		if axis == 0:
			self.ra[name] = values
		else:
			self.ca[name] = values
376786
def to_m(*attrs)
      m=Matrix.build(self.row_size, self.column_size){nil}
      self.each_with_index do |x, row, col|
        if attrs.size == 0 || attrs.nil?
          m[row, col] = x.value
        end
      end
      return m
    end
654667
public void setRow(int row, double[] columns) {
        checkIndices(row, columns.length - 1);

        if (cols <= columns.length)
            cols = columns.length;
        
        SparseDoubleVector rowVec = updateRow(row);

        for (int col = 0; col < cols; ++col) {
            double val = columns[col];
            rowVec.set(col, val);
        }
    }
871602
def setParamValue(self, row, **kwargs):
        
        param = self._parameters[row]
        for key, val in kwargs.items():
            param[key] = val
1314392
public void setLocalValue(final String rowKey, final int col, final Object value) {
        localValues.put(new SheetRowColIndex(rowKey, col), value);
    }
264094
public Object getValue(Object row, int rowIndex, int columnIndex) {
        if (valueModel instanceof NestedValueModel) {
            NestedValueModel nestedModel = (NestedValueModel) valueModel;
            nestedModel.getSourceModel().setValue(row);
        }
        return valueModel.getValue();
    }