Returns the value at the given row and column indexes

@param r the row index, 0 based
@param c the column index, 0 based
346299
public Object get(int r, int c) {
        Column<?> column = column(c);
        return column.get(r);
    }
513538
public Matrix multiply(double c)
    {
        Matrix toReturn = getThisSideMatrix(null);
        toReturn.mutableMultiply(c);
        return toReturn;
    }
1145792
public static void multRow(Matrix A, int i, double c)
    {
        multRow(A, i, 0, A.cols(), c);
    }
387250
public double get(int column, int row) {
        switch (column) {
        case 0:
            switch (row) {
            case 0:
                return m00;
            case 1:
                return m01;
            case 2:
                return m02;
            default:
                break;
            }
            break;
        case 1:
            switch (row) {
            case 0:
                return m10;
            case 1:
                return m11;
            case 2:
                return m12;
            default:
                break;
            }
            break;
        case 2:
            switch (row) {
            case 0:
                return m20;
            case 1:
                return m21;
            case 2:
                return m22;
            default:
                break;
            }
            break;
        default:
            break;
        }
        throw new IllegalArgumentException();
    }
530210
protected Object getValueAt(final MBasicTable table, final int row, final int column) {
		return table.getModel().getValueAt(row, column);
	}
989915
public static void setMatrix(final double[][] m1, final int[] r, final int c0, final int c1, final double[][] m2) {
    assert c0 <= c1 : ERR_INVALID_RANGE;
    assert c1 <= m1[0].length : ERR_MATRIX_DIMENSIONS;
    for(int i = 0; i < r.length; i++) {
      System.arraycopy(m2[i], 0, m1[r[i]], c0, c1 - c0);
    }
  }
1180602
protected T getRowObject(int rowIndex) {
		int pageIndex = rowIndex - dataOffset;
		if (pageIndex >= 0 && pageIndex < data.size()) {
			return data.get(pageIndex);
		}
		return null;
	}
493272
public void setColumn(ColumnVector cv, int c)
        throws MatrixException
    {
        if ((c < 0) || (c >= nCols)) {
            throw new MatrixException(MatrixException.INVALID_INDEX);
        }
        if (nRows != cv.nRows) {
            throw new MatrixException(
                                MatrixException.INVALID_DIMENSIONS);
        }

        for (int r = 0; r < nRows; ++r) {
            this.values[r][c] = cv.values[r][0];
        }
    }
1089916
public static void setMatrix(final double[][] m1, final int[] r, final int[] c, final double[][] m2) {
    for(int i = 0; i < r.length; i++) {
      final double[] row1 = m1[r[i]], row2 = m2[i];
      for(int j = 0; j < c.length; j++) {
        row1[c[j]] = row2[j];
      }
    }
  }
201336
public List<byte[]> allSat(final int r) {
    final byte[] allsatProfile = new byte[this.varnum];
    for (int v = level(r) - 1; v >= 0; --v)
      allsatProfile[this.level2var[v]] = -1;
    initRef();
    final List<byte[]> allSat = new LinkedList<>();
    allSatRec(r, allSat, allsatProfile);
    return allSat;
  }
188
public void scalarMultiply(double c)
    {
        int m = rows;
        int n = cols;
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                consumer.set(i, j, c * supplier.get(i, j));
            }
        }
    }
135130
public DataRow findRowIgnoreCase(int columnIndex, String value)
	{
		for (DataRow dataRow : dataRows)
		{
			String columnValue = (String) dataRow.getColumn(columnIndex);
			if (value.equalsIgnoreCase(columnValue))
			{
				return dataRow;
			}
		}
		return null;
	}
124568
public float get(int row, int col) {
        if (row < 0 || row > 3) {
            throw new IndexOutOfBoundsException("Index: " + row + ", Size: 4");
        }
        if (col < 0 || col > 3) {
            throw new IndexOutOfBoundsException("Index: " + col + ", Size: 4");
        }

        return m_data[row * 4 + col];
    }
1193441
public static double[][] getMatrix(final double[][] m1, final int[] r, final int c0, final int c1) {
    assert c0 <= c1 : ERR_INVALID_RANGE;
    assert c1 <= m1[0].length : ERR_MATRIX_DIMENSIONS;
    final int rowdim = r.length, coldim = c1 - c0;
    final double[][] X = new double[rowdim][coldim];
    for(int i = 0; i < rowdim; i++) {
      System.arraycopy(m1[r[i]], c0, X[i], 0, coldim);
    }
    return X;
  }
973833
@Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        LogRecord log = logRecords.get(rowIndex);
        if (log != null) {
            Object[] params = log.getParameters();
            switch (columnIndex) {
                case 0:
                    return Integer.parseInt((String) log.getParameters()[0]);
                case 1:
                    if (params != null) {
                        return log.getParameters()[1];
                    }
                    break;
                case 2:
                	if (params != null) {
                        Automaton aut = (Automaton) params[5];
                        return aut.getAgent().getId();
                    }
                    return log.getLoggerName();
                case 3:
                    if (params != null) {
                        return params[2];
                    }
                    break;
                case 4:
                    if (params != null) {
                        return params[3];
                    }
                    break;
                case 5:
                    if (params != null) {
                        return params[4];
                    }
                    break;
                case 6:
                    if (params != null) {
                        Automaton aut = (Automaton) params[5];
                        return aut.getFinishCondition();
                    }
                    break;
                case 7:
                    return log.getMessage();
            }
        }
        return "";
    }
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;
            }
        }
    }
352781
public void addRow(Object[] r) {

        Object[] row = new Object[r.length];

        // System.arraycopy(r, 0, row, 0, r.length);
        for (int i = 0; i < r.length; i++) {
            row[i] = r[i];

            if (row[i] == null) {

//                row[i] = "(null)";
            }
        }

        rows.addElement(row);
    }