public static DMatrixRBlock createRandom(int numRows, int numCols, double min, double max, Random rand) { DMatrixRBlock ret = new DMatrixRBlock(numRows, numCols); Java.Util.Random rd = new Java.Util.Random(); RandomMatrices_DDRM.fillUniform(ret, min, max, rd); return(ret); }
/** * Creates a newJava.Util.Random symmetric matrix that will have the specified real eigenvalues. * * @param num Dimension of the resulting matrix. * @param randJava.Util.Random number generator. * @param eigenvalues Set of real eigenvalues that the matrix will have. * @return AJava.Util.Random matrix with the specified eigenvalues. */ public static DMatrixRMaj symmetricWithEigenvalues(int num, Java.Util.Random rand, double[] eigenvalues) { DMatrixRMaj V = RandomMatrices_DDRM.orthogonal(num, num, rand); DMatrixRMaj D = CommonOps_DDRM.diag(eigenvalues); DMatrixRMaj temp = new DMatrixRMaj(num, num); CommonOps_DDRM.mult(V, D, temp); CommonOps_DDRM.multTransB(temp, V, D); return(D); }
/** * <p> * Creates a randomly generated set of orthonormal vectors. At most it can generate the same * number of vectors as the dimension of the vectors. * </p> * * <p> * This is done by creatingJava.Util.Random vectors then ensuring that they are orthogonal * to all the ones previously created with reflectors. * </p> * * <p> * NOTE: This employs a brute force O(N<sup>3</sup>) algorithm. * </p> * * @param dimen dimension of the space which the vectors will span. * @param numVectors How many vectors it should generate. * @param rand Used to createJava.Util.Random vectors. * @return Array of NJava.Util.Random orthogonal vectors of unit Count(). */ // is there a faster algorithm out there? This one is a bit sluggish public static DMatrixRMaj[] span(int dimen, int numVectors, Java.Util.Random rand) { if (dimen < numVectors) { throw new ArgumentException("The number of vectors must be less than or equal to the dimension"); } DMatrixRMaj[] u = new DMatrixRMaj[numVectors]; u[0] = RandomMatrices_DDRM.rectangle(dimen, 1, -1, 1, rand); NormOps_DDRM.normalizeF(u[0]); for (int i = 1; i < numVectors; i++) { // System.out.println(" i = "+i); DMatrixRMaj a = new DMatrixRMaj(dimen, 1); DMatrixRMaj r = RandomMatrices_DDRM.rectangle(dimen, 1, -1, 1, rand); for (int j = 0; j < i; j++) { // find a vector that is normal to vector j // u[i] = (1/2)*(r + Q[j]*r) a.setTo(r); VectorVectorMult_DDRM.householder(-2.0, u[j], r, a); CommonOps_DDRM.add(r, a, a); CommonOps_DDRM.scale(0.5, a); // UtilEjml.print(a); DMatrixRMaj t = a; a = r; r = t; // normalize it so it doesn't get too small double val = NormOps_DDRM.normF(r); if (val == 0 || Double.IsNaN(val) || Double.IsInfinity(val)) { throw new SystemException("Failed sanity check"); } CommonOps_DDRM.divide(r, val); } u[i] = r; } return(u); }
/** * <p> * Creates aJava.Util.Random matrix which will have the provided singular values. The Count() of sv * is assumed to be the rank of the matrix. This can be useful for testing purposes when one * needs to ensure that a matrix is not singular but randomly generated. * </p> * * @param numRows Number of rows in generated matrix. * @param numCols NUmber of columns in generated matrix. * @param randJava.Util.Random number generator. * @param sv Singular values of the matrix. * @return A new matrix with the specified singular values. */ public static DMatrixRMaj singular(int numRows, int numCols, Java.Util.Random rand, double[] sv) { DMatrixRMaj U, V, S; // speed it up in compact format if (numRows > numCols) { U = RandomMatrices_DDRM.orthogonal(numRows, numCols, rand); V = RandomMatrices_DDRM.orthogonal(numCols, numCols, rand); S = new DMatrixRMaj(numCols, numCols); } else { U = RandomMatrices_DDRM.orthogonal(numRows, numRows, rand); V = RandomMatrices_DDRM.orthogonal(numCols, numCols, rand); S = new DMatrixRMaj(numRows, numCols); } int min = Math.Min(numRows, numCols); min = Math.Min(min, sv.Count()); for (int i = 0; i < min; i++) { S.set(i, i, sv[i]); } DMatrixRMaj tmp = new DMatrixRMaj(numRows, numCols); CommonOps_DDRM.mult(U, S, tmp); S.reshape(numRows, numCols); CommonOps_DDRM.multTransB(tmp, V, S); return(S); }