The following document contains the results of PMD's CPD 6.13.0.
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 324 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 459 |
for (int i = 0; i < a.getBlockSize(); ++i) { ans = ans.add(getInnerProduct(a.getBlock(i), b.getBlock(i))); } return ans; } /** * getCholesky(retMat,aMat)をret=getCholesky(aMat)に変更 * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a 元になる行列 * @return ret 結果retMatと同じ */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> getCholesky(DenseMatrix<RS,RM,CS,CM> a) { final RS unit = a.getElementUnit(); DenseMatrix<RS,RM,CS,CM> ans; switch (a.getDenseOrDiagonal()) { case DENSE: ans = a.createClone(); int info = Clapack.dpotrf("Lower", ans.getRowSize(), ans.denseElements, ans.getRowSize()); //$NON-NLS-1$ if (info != 0) { throw new RuntimeException("cannot cholesky decomposition\n" + "Could you try with smaller gammaStar?"); //$NON-NLS-1$ //$NON-NLS-2$ } // Make matrix as lower triangular matrix for (int j = 0; j < ans.getColumnSize(); ++j) { int shou = j / 4; int amari = j % 4; for (int i = 0; i < amari; ++i) { ans.denseElements[i + ans.getColumnSize() * j] = unit.create(0); } int i; int count; for (i = amari, count = 0; count < shou; ++count, i += 4) { ans.denseElements[i + ans.getColumnSize() * j] = unit.create(0); ans.denseElements[i + 1 + ans.getColumnSize() * j] = unit.create(0); ans.denseElements[i + 2 + ans.getColumnSize() * j] = unit.create(0); ans.denseElements[i + 3 + ans.getColumnSize() * j] = unit.create(0); } } return ans; case DIAGONAL: ans = new DenseMatrix<>(a.getRowSize(), a.getColumnSize(), a.getDenseOrDiagonal(), unit); int shou = a.getColumnSize() / 4; int amari = a.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = a.diagonalElements[j].sqrt(); } int j; int count; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = a.diagonalElements[j].sqrt(); ans.diagonalElements[j + 1] = a.diagonalElements[j + 1].sqrt(); ans.diagonalElements[j + 2] = a.diagonalElements[j + 2].sqrt(); ans.diagonalElements[j + 3] = a.diagonalElements[j + 3].sqrt(); } return ans; default: throw new IllegalArgumentException(); } } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @return retMatのコピー */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> getInvLowTriangularMatrix(DenseMatrix<RS,RM,CS,CM> a) { final RS unit = a.getElementUnit(); DenseMatrix<RS,RM,CS,CM> ans = new DenseMatrix<>(a.getRowSize(), a.getColumnSize(), a.getDenseOrDiagonal(), unit); switch (ans.getDenseOrDiagonal()) { case DENSE: ans.setIdentity(unit.create(1)); int nRow = a.getRowSize(); int nCol = a.getColumnSize(); int retnRow = ans.getRowSize(); BLAS.dtrsm("Left", "Lower", "NoTraspose", "NonUnitDiagonal", nRow, nCol, unit.create(1), a.denseElements, nRow, ans.denseElements, retnRow); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ return ans; case DIAGONAL: int shou = a.getColumnSize() / 4; int amari = a.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = unit.create(1).divide(a.diagonalElements[j]); } for (int j = amari, counter = 0; counter < shou; ++counter, j += 4) { ans.diagonalElements[j] = unit.create(1).divide(a.diagonalElements[j]);// 1.0 ans.diagonalElements[j + 1] = unit.create(1).divide(a.diagonalElements[j + 1]); ans.diagonalElements[j + 2] = unit.create(1).divide(a.diagonalElements[j + 2]); ans.diagonalElements[j + 3] = unit.create(1).divide(a.diagonalElements[j + 3]); } return ans; default: throw new IllegalArgumentException(); } } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @return コレスキー分解と逆行列 */ @SuppressWarnings("unchecked") public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM>[] getCholeskyAndInv(BlockDenseMatrix<RS,RM,CS,CM> a) { BlockDenseMatrix<RS,RM,CS,CM> choleskyMat = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); BlockDenseMatrix<RS,RM,CS,CM> inverseMat = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> ans1 = getCholesky(a.getBlock(i)); choleskyMat.setBlock(i, ans1); DenseMatrix<RS,RM,CS,CM> ans2 = getInvLowTriangularMatrix(ans1); inverseMat.setBlock(i, ans2); } return new BlockDenseMatrix[] {choleskyMat, inverseMat}; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> void getSymmetrize(DenseMatrix<RS,RM,CS,CM> a) { final RS unit = a.getElementUnit(); //int index = 0; switch (a.getDenseOrDiagonal()) { case DENSE: if (a.getRowSize() != a.getColumnSize()) { throw new RuntimeException("getSymmetrize:: different memory size"); //$NON-NLS-1$ } for (int index = 0; index < a.getRowSize() - 1; ++index) { int index1 = index + index * a.getRowSize() + 1; int index2 = index + (index + 1) * a.getRowSize(); int length = a.getRowSize() - 1 - index; // aMat.de_ele[index1] += aMat.de_ele[index2] RS[] aMat_index2 = unit.createArray(a.denseElements.length - index2); RS[] aMat_index1 = unit.createArray(a.denseElements.length - index1); System.arraycopy(a.denseElements, index1, aMat_index1, 0, aMat_index1.length); System.arraycopy(a.denseElements, index2, aMat_index2, 0, aMat_index2.length); //BLAS.daxpy(length, unit.create(1), aMat_index2, a.getRowSize(), aMat_index1, 1); BLAS.dxpy(length, aMat_index2, a.getRowSize(), aMat_index1, 1); System.arraycopy(aMat_index1, 0, a.denseElements, index1, aMat_index1.length); // aMat.de_ele[index1] /= 2.0 RS half = unit.create(5).multiply(unit.create(10).power(-1)); System.arraycopy(a.denseElements, index1, aMat_index1, 0, aMat_index1.length); BLAS.dscal(length, half, aMat_index1, 1); System.arraycopy(aMat_index1, 0, a.denseElements, index1, aMat_index1.length); // aMat.de_ele[index2] = aMat.de_ele[index1] RS[] A1 = unit.createArray(a.denseElements.length - index1); System.arraycopy(a.denseElements, index1, A1, 0, A1.length); RS[] A2 = unit.createArray(a.denseElements.length - index2); System.arraycopy(a.denseElements, index2, A2, 0, A2.length); BLAS.dcopy(length, A1, 1, A2, a.getRowSize()); System.arraycopy(A2, 0, a.denseElements, index2, A2.length); } break; case DIAGONAL: // Nothing needs. break; default: throw new IllegalArgumentException(); } } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> void getSymmetrize(BlockDenseMatrix<RS,RM,CS,CM> a) { for (int i = 0; i < a.getBlockSize(); ++i) { getSymmetrize(a.getBlock(i)); } } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @return 転置行列 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> getTranspose(DenseMatrix<RS,RM,CS,CM> a) { if (a.getRowSize() != a.getColumnSize()) { throw new RuntimeException("getTranspose:: different memory size"); //$NON-NLS-1$ // Of course, a non-symmetric matrix has its transposed matrix, // but in this algorithm we have to make transposed matrix only when symmetric matrix. } DenseMatrix<RS,RM,CS,CM> ans = a.createClone(); switch (a.getDenseOrDiagonal()) { case DENSE: for (int i = 0; i < a.getRowSize(); ++i) { int shou = (i + 1) / 4; int amari = (i + 1) / 4; for (int j = 0; j < amari; ++j) { int index1 = i + a.getColumnSize() * j; int index2 = j + a.getColumnSize() * i; ans.denseElements[index1] = a.denseElements[index2]; ans.denseElements[index2] = a.denseElements[index1]; } int counter, j; for (j = amari, counter = 0; counter < shou; ++counter, j += 4) { int index1 = i + a.getColumnSize() * j; int index_1 = j + a.getColumnSize() * i; ans.denseElements[index1] = a.denseElements[index_1]; ans.denseElements[index_1] = a.denseElements[index1]; int index2 = i + a.getColumnSize() * (j + 1); int index_2 = (j + 1) + a.getColumnSize() * i; ans.denseElements[index2] = a.denseElements[index_2]; ans.denseElements[index_2] = a.denseElements[index2]; int index3 = i + a.getColumnSize() * (j + 2); int index_3 = (j + 2) + a.getColumnSize() * i; ans.denseElements[index3] = a.denseElements[index_3]; ans.denseElements[index_3] = a.denseElements[index3]; int index4 = i + a.getColumnSize() * (j + 3); int index_4 = (j + 3) + a.getColumnSize() * i; ans.denseElements[index4] = a.denseElements[index_4]; ans.denseElements[index_4] = a.denseElements[index4]; } } return ans; case DIAGONAL: throw new IllegalArgumentException(); default: throw new IllegalArgumentException(); } } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @return ブロック転置行列 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> getTranspose(BlockDenseMatrix<RS,RM,CS,CM> a) { BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = getTranspose(a.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @return 計算が正常終了したならばtrue */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> boolean choleskyFactorWithAdjust(DenseMatrix<RS,RM,CS,CM> a) { int rowSize = a.getRowSize(); //int info = new Dpotrf<RS>().rATL_dpotrfL(rowSize, a.denseElements, rowSize); //a.setRowSize(rowSize); int info = Clapack.dpotrf("Lower", rowSize, a.denseElements, rowSize); //$NON-NLS-1$ a.setRowSize(rowSize); if (info < 0) { System.err.println("cholesky argument is wrong " + (-info)); //$NON-NLS-1$ return false; } else if (info > 0) { System.err.println("cholesky miss condition :: not positive definite" + " :: info = " + info); //$NON-NLS-1$ //$NON-NLS-2$ return false; } return true; } /** * solve aMat * xVec = bVec aMat must be Cholesky Factorized. aMat must have done Cholesky factorized. * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b b * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> Vector<RS,RM,CS,CM> solveSystems(DenseMatrix<RS,RM,CS,CM> a, Vector<RS,RM,CS,CM> b) { if (a.getRowSize() != b.getDimension() || a.getRowSize() != a.getColumnSize()) { throw new RuntimeException("solveSystems:: different memory size"); //$NON-NLS-1$ } if (a.isDense() == false) { throw new RuntimeException("solveSystems:: matrix type must be DENSE"); //$NON-NLS-1$ } Vector<RS,RM,CS,CM> x = b.createClone(); BLAS.dtrsv("Lower", "NoTranspose", "NonUnit", a.getRowSize(), a.denseElements, a.getColumnSize(), x.getElements(), 1); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ BLAS.dtrsv("Lower", "Transpose", "NonUnit", a.getRowSize(), a.denseElements, a.getColumnSize(), x.getElements(), 1); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ return x; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getColumnSize() != b.getRowSize() || a.getDenseOrDiagonal() != b.getDenseOrDiagonal()) { throw new RuntimeException("multiply :: different matrix size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); DenseMatrix<RS,RM,CS,CM> ans = new DenseMatrix<>(a.getRowSize(), b.getColumnSize(), a.getDenseOrDiagonal(), unit); switch (ans.getDenseOrDiagonal()) { case DENSE: BLAS.dgemm( "NoTranspose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), scalar, a.denseElements, a.getRowSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = scalar.multiply(a.diagonalElements[j].multiply(b.diagonalElements[j])); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = scalar.multiply(a.diagonalElements[j].multiply(b.diagonalElements[j])); ans.diagonalElements[j + 1] = scalar.multiply(a.diagonalElements[j + 1].multiply(b.diagonalElements[j + 1])); ans.diagonalElements[j + 2] = scalar.multiply(a.diagonalElements[j + 2].multiply(b.diagonalElements[j + 2])); ans.diagonalElements[j + 3] = scalar.multiply(a.diagonalElements[j + 3].multiply(b.diagonalElements[j + 3])); } return ans; default: throw new IllegalArgumentException(); } } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { if (a.getColumnSize() != b.getRowSize()) { throw new RuntimeException("multiply :: different matrix size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); DenseMatrix<RS,RM,CS,CM> ans = new DenseMatrix<>(a.getRowSize(), b.getColumnSize(), a.getDenseOrDiagonal(), unit); switch (ans.getDenseOrDiagonal()) { case DENSE: BLAS.dgemm( "NoTranspose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), unit.create(1), a.denseElements, a.getRowSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = a.diagonalElements[j].multiply(b.diagonalElements[j]); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = a.diagonalElements[j].multiply(b.diagonalElements[j]); ans.diagonalElements[j + 1] = a.diagonalElements[j + 1].multiply(b.diagonalElements[j + 1]); ans.diagonalElements[j + 2] = a.diagonalElements[j + 2].multiply(b.diagonalElements[j + 2]); ans.diagonalElements[j + 3] = a.diagonalElements[j + 3].multiply(b.diagonalElements[j + 3]); } return ans; default: throw new IllegalArgumentException(); } } /** * Dense=Sparse*Dense * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply(SparseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getColumnSize() != b.getRowSize()) { throw new RuntimeException("multiply :: different matrix size"); //$NON-NLS-1$ } final RS unit = b.getElementUnit(); DenseMatrix<RS,RM,CS,CM> ans = new DenseMatrix<>(a.getRowSize(), b.getColumnSize(), b.getDenseOrDiagonal(), unit); switch (a.getSparseOrDenseOrDiagonal()) { case SPARSE: if (ans.isDense() == false || b.isDense() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } for (int index = 0; index < a.nonZeroCount; ++index) { int i = a.rowIndex[index]; int j = a.columnIndex[index]; RS value = a.getSparseElement(index).multiply(scalar); if (i != j) { RS[] bMat_j = unit.createArray(b.denseElements.length - j); System.arraycopy(b.denseElements, j, bMat_j, 0, bMat_j.length); RS[] retMat_i = unit.createArray(ans.denseElements.length - i); System.arraycopy(ans.denseElements, i, retMat_i, 0, retMat_i.length); BLAS.daxpy(b.getColumnSize(), value, bMat_j, b.getRowSize(), retMat_i, ans.getRowSize()); System.arraycopy(retMat_i, 0, ans.denseElements, i, retMat_i.length); RS[] bMat_i = unit.createArray(b.denseElements.length - i); System.arraycopy(b.denseElements, i, bMat_i, 0, bMat_i.length); RS[] retMat_j = unit.createArray(ans.denseElements.length - j); System.arraycopy(ans.denseElements, j, retMat_j, 0, retMat_j.length); BLAS.daxpy(b.getColumnSize(), value, bMat_i, b.getRowSize(), retMat_j, ans.getRowSize()); System.arraycopy(retMat_j, 0, ans.denseElements, j, retMat_j.length); } else { RS[] bMat_j = unit.createArray(b.denseElements.length - j); System.arraycopy(b.denseElements, j, bMat_j, 0, bMat_j.length); RS[] retMat_j = unit.createArray(ans.denseElements.length - j); System.arraycopy(ans.denseElements, j, retMat_j, 0, retMat_j.length); BLAS.daxpy(b.getColumnSize(), value, bMat_j, b.getRowSize(), retMat_j, ans.getRowSize()); System.arraycopy(retMat_j, 0, ans.denseElements, j, retMat_j.length); } } return ans; case DENSE: if (ans.isDense() == false || b.isDense() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } BLAS.dgemm( "NoTranspose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), scalar, a.denseElements, a.getRowSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: if (ans.isDiagonal() == false || b.isDiagonal() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = scalar.multiply(a.getDiagonalElement(j).multiply(b.diagonalElements[j])); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = scalar.multiply(a.getDiagonalElement(j)).multiply(b.diagonalElements[j]); ans.diagonalElements[j + 1] = scalar.multiply(a.getDiagonalElement(j + 1).multiply(b.diagonalElements[j + 1])); ans.diagonalElements[j + 2] = scalar.multiply(a.getDiagonalElement(j + 2).multiply(b.diagonalElements[j + 2])); ans.diagonalElements[j + 3] = scalar.multiply(a.getDiagonalElement(j + 3).multiply(b.diagonalElements[j + 3])); } return ans; default: throw new IllegalArgumentException(); } } /** * TODO TODO Dense=Sparse*Dense * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply(SparseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { if (a.getColumnSize() != b.getRowSize()) { throw new RuntimeException("multiply :: different matrix size"); //$NON-NLS-1$ } final RS unit = b.getElementUnit(); DenseMatrix<RS,RM,CS,CM> ans = new DenseMatrix<>(a.getRowSize(), b.getColumnSize(), b.getDenseOrDiagonal(), unit); switch (a.getSparseOrDenseOrDiagonal()) { case SPARSE: if (ans.isDense() == false || b.isDense() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } for (int index = 0; index < a.nonZeroCount; ++index) { int i = a.rowIndex[index]; int j = a.columnIndex[index]; RS value = a.getSparseElement(index); if (i != j) { RS[] bMat_j = unit.createArray(b.denseElements.length - j); System.arraycopy(b.denseElements, j, bMat_j, 0, bMat_j.length); RS[] retMat_i = unit.createArray(ans.denseElements.length - i); System.arraycopy(ans.denseElements, i, retMat_i, 0, retMat_i.length); BLAS.daxpy(b.getColumnSize(), value, bMat_j, b.getRowSize(), retMat_i, ans.getRowSize()); System.arraycopy(retMat_i, 0, ans.denseElements, i, retMat_i.length); RS[] bMat_i = unit.createArray(b.denseElements.length - i); System.arraycopy(b.denseElements, i, bMat_i, 0, bMat_i.length); RS[] retMat_j = unit.createArray(ans.denseElements.length - j); System.arraycopy(ans.denseElements, j, retMat_j, 0, retMat_j.length); BLAS.daxpy(b.getColumnSize(), value, bMat_i, b.getRowSize(), retMat_j, ans.getRowSize()); System.arraycopy(retMat_j, 0, ans.denseElements, j, retMat_j.length); } else { RS[] bMat_j = unit.createArray(b.denseElements.length - j); System.arraycopy(b.denseElements, j, bMat_j, 0, bMat_j.length); RS[] retMat_j = unit.createArray(ans.denseElements.length - j); System.arraycopy(ans.denseElements, j, retMat_j, 0, retMat_j.length); BLAS.daxpy(b.getColumnSize(), value, bMat_j, b.getRowSize(), retMat_j, ans.getRowSize()); System.arraycopy(retMat_j, 0, ans.denseElements, j, retMat_j.length); } } return ans; case DENSE: if (ans.isDense() == false || b.isDense() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } BLAS.dgemm( "NoTranspose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), unit.create(1), a.denseElements, a.getRowSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: if (ans.isDiagonal() == false || b.isDiagonal() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = a.getDiagonalElement(j).multiply(b.diagonalElements[j]); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = a.getDiagonalElement(j).multiply(b.diagonalElements[j]); ans.diagonalElements[j + 1] = a.getDiagonalElement(j + 1).multiply(b.diagonalElements[j + 1]); ans.diagonalElements[j + 2] = a.getDiagonalElement(j + 2).multiply(b.diagonalElements[j + 2]); ans.diagonalElements[j + 3] = a.getDiagonalElement(j + 3).multiply(b.diagonalElements[j + 3]); } return ans; default: throw new IllegalArgumentException(); } } /** * TODO MULTIPLY_NON_ATLASがFalseの場合でやるのもいいかも。 falseの場合でやると、配列のコピーの回数がここの分だけ減る。 Dense=Dense*Sparse * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply(DenseMatrix<RS,RM,CS,CM> a, SparseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getColumnSize() != b.getRowSize()) { throw new RuntimeException("multiply :: different matrix size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); DenseMatrix<RS,RM,CS,CM> ans = new DenseMatrix<>(a.getRowSize(), b.getColumnSize(), a.getDenseOrDiagonal(), unit); switch (b.getSparseOrDenseOrDiagonal()) { case SPARSE: if (ans.isDense() == false || a.isDense() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } for (int index = 0; index < b.nonZeroCount; ++index) { int i = b.rowIndex[index]; int j = b.columnIndex[index]; RS value = b.getSparseElement(index).multiply(scalar); if (i != j) { RS[] aMat_i = unit.createArray(a.denseElements.length - a.getRowSize() * i); System.arraycopy(a.denseElements, a.getRowSize() * i, aMat_i, 0, aMat_i.length); RS[] retMat_j = unit.createArray(ans.denseElements.length - ans.getRowSize() * j); System.arraycopy(ans.denseElements, ans.getRowSize() * j, retMat_j, 0, retMat_j.length); BLAS.daxpy(b.getColumnSize(), value, aMat_i, 1, retMat_j, 1); System.arraycopy(retMat_j, 0, ans.denseElements, ans.getRowSize() * j, retMat_j.length); RS[] aMat_j = unit.createArray(a.denseElements.length - a.getRowSize() * j); System.arraycopy(a.denseElements, a.getRowSize() * j, aMat_j, 0, aMat_j.length); RS[] retMat_i = unit.createArray(ans.denseElements.length - ans.getRowSize() * i); System.arraycopy(ans.denseElements, ans.getRowSize() * i, retMat_i, 0, retMat_i.length); BLAS.daxpy(b.getColumnSize(), value, aMat_j, 1, retMat_i, 1); System.arraycopy(retMat_i, 0, ans.denseElements, ans.getRowSize() * i, retMat_i.length); } else { RS[] aMat_j = unit.createArray(a.denseElements.length - a.getRowSize() * j); RS[] retMat_j = unit.createArray(ans.denseElements.length - ans.getRowSize() * j); System.arraycopy(a.denseElements, a.getRowSize() * j, aMat_j, 0, aMat_j.length); System.arraycopy(ans.denseElements, ans.getRowSize() * j, retMat_j, 0, retMat_j.length); BLAS.daxpy(b.getColumnSize(), value, aMat_j, 1, retMat_j, 1); System.arraycopy(retMat_j, 0, ans.denseElements, ans.getRowSize() * j, retMat_j.length); } } return ans; case DENSE: if (ans.isDense() == false || a.isDense() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } BLAS.dgemm( "NoTranspose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), scalar, a.denseElements, a.getRowSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: if (ans.isDiagonal() == false || a.isDiagonal() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = scalar.multiply(a.diagonalElements[j].multiply(b.getDiagonalElement(j))); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = scalar.multiply(a.diagonalElements[j].multiply(b.getDiagonalElement(j))); ans.diagonalElements[j + 1] = scalar.multiply(a.diagonalElements[j + 1].multiply(b.getDiagonalElement(j + 1))); ans.diagonalElements[j + 2] = scalar.multiply(a.diagonalElements[j + 2].multiply(b.getDiagonalElement(j + 2))); ans.diagonalElements[j + 3] = scalar.multiply(a.diagonalElements[j + 3].multiply(b.getDiagonalElement(j + 3))); } return ans; default: throw new IllegalArgumentException(); } } /** * TODO MULTIPLY_NON_ATLASがFalseの場合でやるのもいいかも。 falseの場合でやると、配列のコピーの回数がここの分だけ減る。 Dense=Dense*Sparse * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply(DenseMatrix<RS,RM,CS,CM> a, SparseMatrix<RS,RM,CS,CM> b) { if (a.getColumnSize() != b.getRowSize()) { throw new RuntimeException("multiply :: different matrix size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); DenseMatrix<RS,RM,CS,CM> ans = new DenseMatrix<>(a.getRowSize(), b.getColumnSize(), a.getDenseOrDiagonal(), unit); switch (b.getSparseOrDenseOrDiagonal()) { case SPARSE: if (ans.isDense() == false || a.isDense() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } for (int index = 0; index < b.nonZeroCount; ++index) { int i = b.rowIndex[index]; int j = b.columnIndex[index]; RS value = b.getSparseElement(index); if (i != j) { RS[] aMat_j = unit.createArray(a.denseElements.length - a.getRowSize() * j); System.arraycopy(a.denseElements, a.getRowSize() * j, aMat_j, 0, aMat_j.length); RS[] retMat_i = unit.createArray(ans.denseElements.length - ans.getRowSize() * i); System.arraycopy(ans.denseElements, ans.getRowSize() * i, retMat_i, 0, retMat_i.length); BLAS.daxpy(b.getColumnSize(), value, aMat_j, 1, retMat_i, 1); System.arraycopy(retMat_i, 0, ans.denseElements, ans.getRowSize() * i, retMat_i.length); RS[] aMat_i = unit.createArray(a.denseElements.length - a.getRowSize() * i); System.arraycopy(a.denseElements, a.getRowSize() * i, aMat_i, 0, aMat_i.length); RS[] retMat_j = unit.createArray(ans.denseElements.length - ans.getRowSize() * j); System.arraycopy(ans.denseElements, ans.getRowSize() * j, retMat_j, 0, retMat_j.length); BLAS.daxpy(b.getColumnSize(), value, aMat_i, 1, retMat_j, 1); System.arraycopy(retMat_j, 0, ans.denseElements, ans.getRowSize() * j, retMat_j.length); } else { RS[] aMat_j = unit.createArray(a.denseElements.length - a.getRowSize() * j); RS[] retMat_j = unit.createArray(ans.denseElements.length - ans.getRowSize() * j); System.arraycopy(a.denseElements, a.getRowSize() * j, aMat_j, 0, aMat_j.length); System.arraycopy(ans.denseElements, ans.getRowSize() * j, retMat_j, 0, retMat_j.length); BLAS.daxpy(b.getColumnSize(), value, aMat_j, 1, retMat_j, 1); System.arraycopy(retMat_j, 0, ans.denseElements, ans.getRowSize() * j, retMat_j.length); } } return ans; case DENSE: if (ans.isDense() == false || a.isDense() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } BLAS.dgemm( "NoTranspose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), unit.create(1), a.denseElements, a.getRowSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: if (ans.isDiagonal() == false || a.isDiagonal() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = a.diagonalElements[j].multiply(b.getDiagonalElement(j)); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = a.diagonalElements[j].multiply(b.getDiagonalElement(j)); ans.diagonalElements[j + 1] = a.diagonalElements[j + 1].multiply(b.getDiagonalElement(j + 1)); ans.diagonalElements[j + 2] = a.diagonalElements[j + 2].multiply(b.getDiagonalElement(j + 2)); ans.diagonalElements[j + 3] = a.diagonalElements[j + 3].multiply(b.getDiagonalElement(j + 3)); } return ans; default: throw new IllegalArgumentException(); } } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply(DenseMatrix<RS,RM,CS,CM> a, RS scalar) { DenseMatrix<RS,RM,CS,CM> ans = a.createClone(); switch (ans.getDenseOrDiagonal()) { case DENSE: int length = ans.getRowSize() * ans.getColumnSize(); BLAS.dscal(length, scalar, ans.denseElements, 1); return ans; case DIAGONAL: BLAS.dscal(ans.getColumnSize(), scalar, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, RS scalar) { BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> Vector<RS,RM,CS,CM> multiply(Vector<RS,RM,CS,CM> a, RS scalar) { Vector<RS,RM,CS,CM> ans = a.createClone(); BLAS.dscal(ans.getDimension(), scalar, ans.getElements(), 1); return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockVector<RS,RM,CS,CM> multiply(BlockVector<RS,RM,CS,CM> a, RS scalar) { BlockVector<RS,RM,CS,CM> ans = a.createClone(); for (int i = 0; i < a.getBlockSize(); ++i) { Vector<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b b * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> Vector<RS,RM,CS,CM> multiply(DenseMatrix<RS,RM,CS,CM> a, Vector<RS,RM,CS,CM> b) { if (a.getColumnSize() != b.getDimension()) { throw new RuntimeException("multiply :: different matrix size"); //$NON-NLS-1$ } Vector<RS,RM,CS,CM> ans = b.createClone(); final RS unit = a.getElementUnit(); switch (a.getDenseOrDiagonal()) { case DENSE: BLAS.dgemv("NoTranspose", a.getRowSize(), a.getColumnSize(), unit.create(1), a.denseElements, a.getRowSize(), b.getElements(), 1, unit.create(0), ans.getElements(), 1); //$NON-NLS-1$ return ans; case DIAGONAL: int shou = ans.getDimension() / 4; int amari = ans.getDimension() % 4; for (int j = 0; j < amari; ++j) { ans.setElement(j, a.diagonalElements[j].multiply(b.getElement(j))); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.setElement(j, a.diagonalElements[j].multiply(b.getElement(j))); ans.setElement(j + 1, a.diagonalElements[j + 1].multiply(b.getElement(j + 1))); ans.setElement(j + 2, a.diagonalElements[j + 2].multiply(b.getElement(j + 2))); ans.setElement(j + 3, a.diagonalElements[j + 3].multiply(b.getElement(j + 3))); } return ans; default: throw new IllegalArgumentException(); } } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b b * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> Vector<RS,RM,CS,CM> multiply(DenseMatrix<RS,RM,CS,CM> a, Vector<RS,RM,CS,CM> b, RS scalar) { if (a.getColumnSize() != b.getDimension()) { throw new RuntimeException("multiply :: different matrix size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); Vector<RS,RM,CS,CM> ans = new Vector<>(a.getRowSize(), unit); switch (a.getDenseOrDiagonal()) { case DENSE: BLAS.dgemv("NoTranspose", a.getRowSize(), a.getColumnSize(), scalar, a.denseElements, a.getRowSize(), b.getElements(), 1, unit.create(0), ans.getElements(), 1); //$NON-NLS-1$ return ans; case DIAGONAL: int shou = ans.getDimension() / 4; int amari = ans.getDimension() % 4; for (int j = 0; j < amari; ++j) { ans.setElement(j, scalar.multiply(a.diagonalElements[j].multiply(b.getElement(j)))); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.setElement(j, scalar.multiply(a.diagonalElements[j].multiply(b.getElement(j)))); ans.setElement(j + 1, scalar.multiply(a.diagonalElements[j + 1].multiply(b.getElement(j + 1)))); ans.setElement(j + 2, scalar.multiply(a.diagonalElements[j + 2].multiply(b.getElement(j + 2)))); ans.setElement(j + 3, scalar.multiply(a.diagonalElements[j + 3].multiply(b.getElement(j + 3)))); } return ans; default: throw new IllegalArgumentException(); } } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b b * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockVector<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockVector<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); BlockVector<RS,RM,CS,CM> ans = new BlockVector<>(a.getBlockSize(), a.getBlockStructs(), unit); for (int i = 0; i < a.getBlockSize(); ++i) { Vector<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b b * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockVector<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockVector<RS,RM,CS,CM> b) { if (b.getBlockSize() != a.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockVector<RS,RM,CS,CM> ans = b.createClone(); for (int i = 0; i < b.getBlockSize(); ++i) { Vector<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = a.createClone(); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockSparseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(b.getBlockSize(), b.getBlockStructs(), b.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockSparseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(b.getBlockSize(), b.getBlockStructs(), b.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockSparseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockSparseMatrix<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans = aMat**T * bMat * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> tran_multiply(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getRowSize() != b.getRowSize() || a.getDenseOrDiagonal() != b.getDenseOrDiagonal()) { Tools.error("multiply :: different matrix size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); DenseMatrix<RS,RM,CS,CM> ans = new DenseMatrix<>(a.getColumnSize(), b.getColumnSize(), a.getDenseOrDiagonal(), unit); switch (ans.getDenseOrDiagonal()) { case DENSE: BLAS.dgemm( "Transpose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), scalar, a.denseElements, a.getColumnSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = scalar.multiply(a.diagonalElements[j].multiply(b.diagonalElements[j])); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = scalar.multiply(a.diagonalElements[j].multiply(b.diagonalElements[j])); ans.diagonalElements[j + 1] = scalar.multiply(a.diagonalElements[j + 1].multiply(b.diagonalElements[j + 1])); ans.diagonalElements[j + 2] = scalar.multiply(a.diagonalElements[j + 2].multiply(b.diagonalElements[j + 2])); ans.diagonalElements[j + 3] = scalar.multiply(a.diagonalElements[j + 3].multiply(b.diagonalElements[j + 3])); } return ans; default: throw new IllegalArgumentException(); } } /** * ans = aMat**T * bMat * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> tran_multiply(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { if (a.getRowSize() != b.getRowSize() || a.getDenseOrDiagonal() != b.getDenseOrDiagonal()) { Tools.error("multiply :: different matrix size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); DenseMatrix<RS,RM,CS,CM> ans = new DenseMatrix<>(a.getColumnSize(), b.getColumnSize(), a.getDenseOrDiagonal(), unit); switch (ans.getDenseOrDiagonal()) { case DENSE: BLAS.dgemm( "Transpose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), unit.create(1), a.denseElements, a.getColumnSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = a.diagonalElements[j].multiply(b.diagonalElements[j]); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = a.diagonalElements[j].multiply(b.diagonalElements[j]); ans.diagonalElements[j + 1] = a.diagonalElements[j + 1].multiply(b.diagonalElements[j + 1]); ans.diagonalElements[j + 2] = a.diagonalElements[j + 2].multiply(b.diagonalElements[j + 2]); ans.diagonalElements[j + 3] = a.diagonalElements[j + 3].multiply(b.diagonalElements[j + 3]); } return ans; default: throw new IllegalArgumentException(); } } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> tran_multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = tran_multiply(a.getBlock(i), b.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> tran_multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = tran_multiply(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans = aMat * bMat**T * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply_tran(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getColumnSize() != b.getColumnSize() || a.getDenseOrDiagonal() != b.getDenseOrDiagonal()) { Tools.error("multiply :: different matrix size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); DenseMatrix<RS,RM,CS,CM> ans = new DenseMatrix<>(a.getRowSize(), b.getRowSize(), a.getDenseOrDiagonal(), unit); switch (ans.getDenseOrDiagonal()) { case DENSE: // The Point is the first argument is "NoTranspose". BLAS.dgemm( "NoTranspose", "Transpose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), scalar, a.denseElements, a.getRowSize(), b.denseElements, b.getColumnSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = scalar.multiply(a.diagonalElements[j].multiply(b.diagonalElements[j])); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = scalar.multiply(a.diagonalElements[j].multiply(b.diagonalElements[j])); ans.diagonalElements[j + 1] = scalar.multiply(a.diagonalElements[j + 1].multiply(b.diagonalElements[j + 1])); ans.diagonalElements[j + 2] = scalar.multiply(a.diagonalElements[j + 2].multiply(b.diagonalElements[j + 2])); ans.diagonalElements[j + 3] = scalar.multiply(a.diagonalElements[j + 3].multiply(b.diagonalElements[j + 3])); } return ans; default: throw new IllegalArgumentException(); } } /** * ans = aMat * bMat**T * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply_tran(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { if (a.getColumnSize() != b.getColumnSize()) { Tools.error("multiply :: different matrix size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); DenseMatrix<RS,RM,CS,CM> ans = new DenseMatrix<>(a.getRowSize(), b.getRowSize(), a.getDenseOrDiagonal(), unit); switch (ans.getDenseOrDiagonal()) { case DENSE: // The Point is the first argument is "NoTranspose". BLAS.dgemm( "NoTranspose", "Transpose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), unit.create(1), a.denseElements, a.getRowSize(), b.denseElements, b.getColumnSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = a.diagonalElements[j].multiply(b.diagonalElements[j]); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = a.diagonalElements[j].multiply(b.diagonalElements[j]); ans.diagonalElements[j + 1] = a.diagonalElements[j + 1].multiply(b.diagonalElements[j + 1]); ans.diagonalElements[j + 2] = a.diagonalElements[j + 2].multiply(b.diagonalElements[j + 2]); ans.diagonalElements[j + 3] = a.diagonalElements[j + 3].multiply(b.diagonalElements[j + 3]); } return ans; default: throw new IllegalArgumentException(); } } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply_tran(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply_tran(a.getBlock(i), b.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply_tran(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { RS scalar = null; BlockDenseMatrix<RS,RM,CS,CM> ans = multiply_tran(a, b, scalar); return ans; } /** * ans = a + b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param b b * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> Vector<RS,RM,CS,CM> plus(Vector<RS,RM,CS,CM> a, Vector<RS,RM,CS,CM> b, RS scalar) { if (a.getDimension() != b.getDimension()) { throw new RuntimeException("plus :: different matrix size"); //$NON-NLS-1$ } Vector<RS,RM,CS,CM> ans = a.createClone(); BLAS.daxpy(ans.getDimension(), scalar, b.getElements(), 1, ans.getElements(), 1); return ans; } /** * ans = a + b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param b b * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> Vector<RS,RM,CS,CM> plus(Vector<RS,RM,CS,CM> a, Vector<RS,RM,CS,CM> b) { if (a.getDimension() != b.getDimension()) { throw new RuntimeException("plus :: different matrix size"); //$NON-NLS-1$ } Vector<RS,RM,CS,CM> ans = a.createClone(); BLAS.dxpy(ans.getDimension(), b.getElements(), 1, ans.getElements(), 1); return ans; } /** * ans = a - b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param b b * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> Vector<RS,RM,CS,CM> minus(Vector<RS,RM,CS,CM> a, Vector<RS,RM,CS,CM> b) { if (a.getDimension() != b.getDimension()) { throw new RuntimeException("minus :: different matrix size"); //$NON-NLS-1$ } Vector<RS,RM,CS,CM> ans = a.createClone(); BLAS.dxmy(ans.getDimension(), b.getElements(), 1, ans.getElements(), 1); return ans; } /** * ans = a + b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> plus(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getRowSize() != b.getRowSize() || a.getColumnSize() != b.getColumnSize() || a.getDenseOrDiagonal() != b.getDenseOrDiagonal()) { throw new RuntimeException("plus :: different matrix size"); //$NON-NLS-1$ } DenseMatrix<RS,RM,CS,CM> ans = a.createClone(); switch (a.getDenseOrDiagonal()) { case DENSE: int length = a.getRowSize() * a.getColumnSize(); BLAS.daxpy(length, scalar, b.denseElements, 1, ans.denseElements, 1); return ans; case DIAGONAL: BLAS.daxpy(ans.getColumnSize(), scalar, b.diagonalElements, 1, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * ans = a + b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> plus(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { if (a.getRowSize() != b.getRowSize() || a.getColumnSize() != b.getColumnSize() || a.getDenseOrDiagonal() != b.getDenseOrDiagonal()) { throw new RuntimeException("plus :: different matrix size"); //$NON-NLS-1$ } final DenseMatrix<RS,RM,CS,CM> ans; switch (a.getDenseOrDiagonal()) { case DENSE: int length = a.getRowSize() * a.getColumnSize(); ans = a.createClone(); BLAS.dxpy(length, b.denseElements, 1, ans.denseElements, 1); return ans; case DIAGONAL: ans = a.createClone(); BLAS.dxpy(ans.getColumnSize(), b.diagonalElements, 1, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * ans = a - b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> minus(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { if (a.getRowSize() != b.getRowSize() || a.getColumnSize() != b.getColumnSize() || a.getDenseOrDiagonal() != b.getDenseOrDiagonal()) { throw new RuntimeException("minus :: different matrix size"); //$NON-NLS-1$ } final DenseMatrix<RS,RM,CS,CM> ans; switch (a.getDenseOrDiagonal()) { case DENSE: int length = a.getRowSize() * a.getColumnSize(); ans = a.createClone(); BLAS.dxmy(length, b.denseElements, 1, ans.denseElements, 1); return ans; case DIAGONAL: ans = a.createClone(); BLAS.dxmy(ans.getColumnSize(), b.diagonalElements, 1, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * ans = a + b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> plus(SparseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getRowSize() != b.getRowSize() || a.getColumnSize() != b.getColumnSize()) { throw new RuntimeException("plus :: different matrix size"); //$NON-NLS-1$ } // ret = (*scalar) * b DenseMatrix<RS,RM,CS,CM> ans = multiply(b, scalar); // ret += a switch (a.getSparseOrDenseOrDiagonal()) { case SPARSE: if (ans.isDense() == false || b.isDense() == false) { throw new RuntimeException("plus :: different matrix type"); //$NON-NLS-1$ } int shou = a.nonZeroCount / 4; int amari = a.nonZeroCount % 4; for (int index = 0; index < amari; ++index) { int i = a.rowIndex[index]; int j = a.columnIndex[index]; RS value = a.getSparseElement(index); if (i != j) { int ij = i + ans.getColumnSize() * j; int ji = j + ans.getColumnSize() * i; ans.denseElements[ij] = ans.denseElements[ij].add(value); ans.denseElements[ji] = ans.denseElements[ji].add(value); } else { int ii = i + ans.getColumnSize() * i; ans.denseElements[ii] = ans.denseElements[ii].add(value); } } int index; int counter; for (index = amari, counter = 0; counter < shou; ++counter, index += 4) { int i1 = a.rowIndex[index]; int j1 = a.columnIndex[index]; RS value1 = a.getSparseElement(index); if (i1 != j1) { int ij = i1 + ans.getColumnSize() * j1; int ji = j1 + ans.getColumnSize() * i1; ans.denseElements[ij] = ans.denseElements[ij].add(value1); ans.denseElements[ji] = ans.denseElements[ji].add(value1); } else { int ii = i1 + ans.getColumnSize() * i1; ans.denseElements[ii] = ans.denseElements[ii].add(value1); } int i2 = a.rowIndex[index + 1]; int j2 = a.columnIndex[index + 1]; RS value2 = a.getSparseElement(index + 1); if (i2 != j2) { int ij = i2 + ans.getColumnSize() * j2; int ji = j2 + ans.getColumnSize() * i2; ans.denseElements[ij] = ans.denseElements[ij].add(value2); ans.denseElements[ji] = ans.denseElements[ji].add(value2); } else { int ii = i2 + ans.getColumnSize() * i2; ans.denseElements[ii] = ans.denseElements[ii].add(value2); } int i3 = a.rowIndex[index + 2]; int j3 = a.columnIndex[index + 2]; RS value3 = a.getSparseElement(index + 2); if (i3 != j3) { int ij = i3 + ans.getColumnSize() * j3; int ji = j3 + ans.getColumnSize() * i3; ans.denseElements[ij] = ans.denseElements[ij].add(value3); ans.denseElements[ji] = ans.denseElements[ji].add(value3); } else { int ii = i3 + ans.getColumnSize() * i3; ans.denseElements[ii] = ans.denseElements[ii].add(value3); } int i4 = a.rowIndex[index + 3]; int j4 = a.columnIndex[index + 3]; RS value4 = a.getSparseElement(index + 3); if (i4 != j4) { int ij = i4 + ans.getColumnSize() * j4; int ji = j4 + ans.getColumnSize() * i4; ans.denseElements[ij] = ans.denseElements[ij].add(value4); ans.denseElements[ji] = ans.denseElements[ji].add(value4); } else { int ii = i4 + ans.getColumnSize() * i4; ans.denseElements[ii] = ans.denseElements[ii].add(value4); } } return ans; case DENSE: if (ans.isDense() == false || b.isDense() == false) { throw new RuntimeException("plus :: different matrix type"); //$NON-NLS-1$ } int length = ans.getRowSize() * ans.getColumnSize(); BLAS.dxpy(length, a.denseElements, 1, ans.denseElements, 1); return ans; case DIAGONAL: if (ans.isDiagonal() == false || b.isDiagonal() == false) { throw new RuntimeException("plus :: different matrix type"); //$NON-NLS-1$ } BLAS.dxpy(ans.getColumnSize(), a.diagonalElements, 1, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * ans = a + b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> plus(SparseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { if (a.getRowSize() != b.getRowSize() || a.getColumnSize() != b.getColumnSize()) { throw new RuntimeException("plus :: different matrix size"); //$NON-NLS-1$ } DenseMatrix<RS,RM,CS,CM> ans = b.createClone(); switch (a.getSparseOrDenseOrDiagonal()) { case SPARSE: if (b.isDense() == false) { throw new RuntimeException("plus :: different matrix type"); //$NON-NLS-1$ } int shou = a.nonZeroCount / 4; int amari = a.nonZeroCount % 4; for (int index = 0; index < amari; ++index) { int i = a.rowIndex[index]; int j = a.columnIndex[index]; RS value = a.getSparseElement(index); if (i != j) { int ij = i + ans.getColumnSize() * j; int ji = j + ans.getColumnSize() * i; ans.denseElements[ij] = ans.denseElements[ij].add(value); ans.denseElements[ji] = ans.denseElements[ji].add(value); } else { int ii = i + ans.getColumnSize() * i; ans.denseElements[ii] = ans.denseElements[ii].add(value); } } int index; int counter; for (index = amari, counter = 0; counter < shou; ++counter, index += 4) { int i1 = a.rowIndex[index]; int j1 = a.columnIndex[index]; RS value1 = a.getSparseElement(index); if (i1 != j1) { int ij = i1 + ans.getColumnSize() * j1; int ji = j1 + ans.getColumnSize() * i1; ans.denseElements[ij] = ans.denseElements[ij].add(value1); ans.denseElements[ji] = ans.denseElements[ji].add(value1); } else { int ii = i1 + ans.getColumnSize() * i1; ans.denseElements[ii] = ans.denseElements[ii].add(value1); } int i2 = a.rowIndex[index + 1]; int j2 = a.columnIndex[index + 1]; RS value2 = a.getSparseElement(index + 1); if (i2 != j2) { int ij = i2 + ans.getColumnSize() * j2; int ji = j2 + ans.getColumnSize() * i2; ans.denseElements[ij] = ans.denseElements[ij].add(value2); ans.denseElements[ji] = ans.denseElements[ji].add(value2); } else { int ii = i2 + ans.getColumnSize() * i2; ans.denseElements[ii] = ans.denseElements[ii].add(value2); } int i3 = a.rowIndex[index + 2]; int j3 = a.columnIndex[index + 2]; RS value3 = a.getSparseElement(index + 2); if (i3 != j3) { int ij = i3 + ans.getColumnSize() * j3; int ji = j3 + ans.getColumnSize() * i3; ans.denseElements[ij] = ans.denseElements[ij].add(value3); ans.denseElements[ji] = ans.denseElements[ji].add(value3); } else { int ii = i3 + ans.getColumnSize() * i3; ans.denseElements[ii] = ans.denseElements[ii].add(value3); } int i4 = a.rowIndex[index + 3]; int j4 = a.columnIndex[index + 3]; RS value4 = a.getSparseElement(index + 3); if (i4 != j4) { int ij = i4 + ans.getColumnSize() * j4; int ji = j4 + ans.getColumnSize() * i4; ans.denseElements[ij] = ans.denseElements[ij].add(value4); ans.denseElements[ji] = ans.denseElements[ji].add(value4); } else { int ii = i4 + ans.getColumnSize() * i4; ans.denseElements[ii] = ans.denseElements[ii].add(value4); } } return ans; case DENSE: if (b.isDense() == false) { throw new RuntimeException("plus :: different matrix type"); //$NON-NLS-1$ } int length = ans.getRowSize() * ans.getColumnSize(); BLAS.dxpy(length, a.denseElements, 1, ans.denseElements, 1); return ans; case DIAGONAL: if (b.isDiagonal() == false) { throw new RuntimeException("plus :: different matrix type"); //$NON-NLS-1$ } BLAS.dxpy(ans.getColumnSize(), a.diagonalElements, 1, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * ans = a - b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> minus(SparseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { if (a.getRowSize() != b.getRowSize() || a.getColumnSize() != b.getColumnSize()) { throw new RuntimeException("minus :: different matrix size"); //$NON-NLS-1$ } DenseMatrix<RS,RM,CS,CM> ans = b.createClone(); switch (a.getSparseOrDenseOrDiagonal()) { case SPARSE: if (b.isDense() == false) { throw new RuntimeException("minus :: different matrix type"); //$NON-NLS-1$ } int shou = a.nonZeroCount / 4; int amari = a.nonZeroCount % 4; for (int index = 0; index < amari; ++index) { int i = a.rowIndex[index]; int j = a.columnIndex[index]; RS value = a.getSparseElement(index); if (i != j) { int ij = i + ans.getColumnSize() * j; int ji = j + ans.getColumnSize() * i; ans.denseElements[ij] = ans.denseElements[ij].subtract(value); ans.denseElements[ji] = ans.denseElements[ji].subtract(value); } else { int ii = i + ans.getColumnSize() * i; ans.denseElements[ii] = ans.denseElements[ii].subtract(value); } } int index; int counter; for (index = amari, counter = 0; counter < shou; ++counter, index += 4) { int i1 = a.rowIndex[index]; int j1 = a.columnIndex[index]; RS value1 = a.getSparseElement(index); if (i1 != j1) { int ij = i1 + ans.getColumnSize() * j1; int ji = j1 + ans.getColumnSize() * i1; ans.denseElements[ij] = ans.denseElements[ij].subtract(value1); ans.denseElements[ji] = ans.denseElements[ji].subtract(value1); } else { int ii = i1 + ans.getColumnSize() * i1; ans.denseElements[ii] = ans.denseElements[ii].subtract(value1); } int i2 = a.rowIndex[index + 1]; int j2 = a.columnIndex[index + 1]; RS value2 = a.getSparseElement(index + 1); if (i2 != j2) { int ij = i2 + ans.getColumnSize() * j2; int ji = j2 + ans.getColumnSize() * i2; ans.denseElements[ij] = ans.denseElements[ij].subtract(value2); ans.denseElements[ji] = ans.denseElements[ji].subtract(value2); } else { int ii = i2 + ans.getColumnSize() * i2; ans.denseElements[ii] = ans.denseElements[ii].subtract(value2); } int i3 = a.rowIndex[index + 2]; int j3 = a.columnIndex[index + 2]; RS value3 = a.getSparseElement(index + 2); if (i3 != j3) { int ij = i3 + ans.getColumnSize() * j3; int ji = j3 + ans.getColumnSize() * i3; ans.denseElements[ij] = ans.denseElements[ij].subtract(value3); ans.denseElements[ji] = ans.denseElements[ji].subtract(value3); } else { int ii = i3 + ans.getColumnSize() * i3; ans.denseElements[ii] = ans.denseElements[ii].subtract(value3); } int i4 = a.rowIndex[index + 3]; int j4 = a.columnIndex[index + 3]; RS value4 = a.getSparseElement(index + 3); if (i4 != j4) { int ij = i4 + ans.getColumnSize() * j4; int ji = j4 + ans.getColumnSize() * i4; ans.denseElements[ij] = ans.denseElements[ij].subtract(value4); ans.denseElements[ji] = ans.denseElements[ji].subtract(value4); } else { int ii = i4 + ans.getColumnSize() * i4; ans.denseElements[ii] = ans.denseElements[ii].subtract(value4); } } return ans; case DENSE: if (b.isDense() == false) { throw new RuntimeException("minus :: different matrix type"); //$NON-NLS-1$ } int length = ans.getRowSize() * ans.getColumnSize(); BLAS.dxmy(length, a.denseElements, 1, ans.denseElements, 1); return ans; case DIAGONAL: if (b.isDiagonal() == false) { throw new RuntimeException("minus :: different matrix type"); //$NON-NLS-1$ } BLAS.dxmy(ans.getColumnSize(), a.diagonalElements, 1, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * ans = a + b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> plus(DenseMatrix<RS,RM,CS,CM> a, SparseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getRowSize() != b.getRowSize() || a.getColumnSize() != b.getColumnSize()) { throw new RuntimeException("plus :: different matrix size"); //$NON-NLS-1$ } // ret = a DenseMatrix<RS,RM,CS,CM> ans = a.createClone(); //ret += (*scalar) * b switch (b.getSparseOrDenseOrDiagonal()) { case SPARSE: if (ans.isDense() == false || a.isDense() == false) { throw new RuntimeException("plus :: different matrix type"); //$NON-NLS-1$ } int shou = b.nonZeroCount / 4; int amari = b.nonZeroCount % 4; for (int index = 0; index < amari; ++index) { int i = b.rowIndex[index]; int j = b.columnIndex[index]; RS value = b.getSparseElement(index).multiply(scalar); if (i != j) { int ij = i + ans.getColumnSize() * j; int ji = j + ans.getColumnSize() * i; ans.denseElements[ij] = ans.denseElements[ij].add(value); ans.denseElements[ji] = ans.denseElements[ji].add(value); } else { int ii = i + ans.getColumnSize() * i; ans.denseElements[ii] = ans.denseElements[ii].add(value); } } int index; int counter; for (index = amari, counter = 0; counter < shou; ++counter, index += 4) { int i1 = b.rowIndex[index]; int j1 = b.columnIndex[index]; RS value1 = b.getSparseElement(index).multiply(scalar); if (i1 != j1) { int ij = i1 + ans.getColumnSize() * j1; int ji = j1 + ans.getColumnSize() * i1; ans.denseElements[ij] = ans.denseElements[ij].add(value1); ans.denseElements[ji] = ans.denseElements[ji].add(value1); } else { int ii = i1 + ans.getColumnSize() * i1; ans.denseElements[ii] = ans.denseElements[ii].add(value1); } int i2 = b.rowIndex[index + 1]; int j2 = b.columnIndex[index + 1]; RS value2 = b.getSparseElement(index + 1).multiply(scalar); if (i2 != j2) { int ij = i2 + ans.getColumnSize() * j2; int ji = j2 + ans.getColumnSize() * i2; ans.denseElements[ij] = ans.denseElements[ij].add(value2); ans.denseElements[ji] = ans.denseElements[ji].add(value2); } else { int ii = i2 + ans.getColumnSize() * i2; ans.denseElements[ii] = ans.denseElements[ii].add(value2); } int i3 = b.rowIndex[index + 2]; int j3 = b.columnIndex[index + 2]; RS value3 = b.getSparseElement(index + 2).multiply(scalar); if (i3 != j3) { int ij = i3 + ans.getColumnSize() * j3; int ji = j3 + ans.getColumnSize() * i3; ans.denseElements[ij] = ans.denseElements[ij].add(value3); ans.denseElements[ji] = ans.denseElements[ji].add(value3); } else { int ii = i3 + ans.getColumnSize() * i3; ans.denseElements[ii] = ans.denseElements[ii].add(value3); } int i4 = b.rowIndex[index + 3]; int j4 = b.columnIndex[index + 3]; RS value4 = b.getSparseElement(index + 3).multiply(scalar); if (i4 != j4) { int ij = i4 + ans.getColumnSize() * j4; int ji = j4 + ans.getColumnSize() * i4; ans.denseElements[ij] = ans.denseElements[ij].add(value4); ans.denseElements[ji] = ans.denseElements[ji].add(value4); } else { int ii = i4 + ans.getColumnSize() * i4; ans.denseElements[ii] = ans.denseElements[ii].add(value4); } } return ans; case DENSE: if (ans.isDense() == false || a.isDense() == false) { throw new RuntimeException("plus :: different matrix type"); //$NON-NLS-1$ } int length = ans.getRowSize() * ans.getColumnSize(); BLAS.daxpy(length, scalar, b.denseElements, 1, ans.denseElements, 1); return ans; case DIAGONAL: if (ans.isDiagonal() == false || a.isDiagonal() == false) { throw new RuntimeException("plus :: different matrix type"); //$NON-NLS-1$ } BLAS.daxpy(ans.getColumnSize(), scalar, b.diagonalElements, 1, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * ans = a + b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> plus(DenseMatrix<RS,RM,CS,CM> a, SparseMatrix<RS,RM,CS,CM> b) { if (a.getRowSize() != b.getRowSize() || a.getColumnSize() != b.getColumnSize()) { throw new RuntimeException("plus :: different matrix size"); //$NON-NLS-1$ } // ans = a DenseMatrix<RS,RM,CS,CM> ans = a.createClone(); // ans += (*scalar) * b switch (b.getSparseOrDenseOrDiagonal()) { case SPARSE: int shou = b.nonZeroCount / 4; int amari = b.nonZeroCount % 4; for (int index = 0; index < amari; ++index) { int i = b.rowIndex[index]; int j = b.columnIndex[index]; RS value = b.getSparseElement(index); if (i != j) { int ij = i + ans.getColumnSize() * j; int ji = j + ans.getColumnSize() * i; ans.denseElements[ij] = ans.denseElements[ij].add(value); ans.denseElements[ji] = ans.denseElements[ji].add(value); } else { int ii = i + ans.getColumnSize() * i; ans.denseElements[ii] = ans.denseElements[ii].add(value); } } int index; int counter; for (index = amari, counter = 0; counter < shou; ++counter, index += 4) { int i1 = b.rowIndex[index]; int j1 = b.columnIndex[index]; RS value1 = b.getSparseElement(index); if (i1 != j1) { int ij = i1 + ans.getColumnSize() * j1; int ji = j1 + ans.getColumnSize() * i1; ans.denseElements[ij] = ans.denseElements[ij].add(value1); ans.denseElements[ji] = ans.denseElements[ji].add(value1); } else { int ii = i1 + ans.getColumnSize() * i1; ans.denseElements[ii] = ans.denseElements[ii].add(value1); } int i2 = b.rowIndex[index + 1]; int j2 = b.columnIndex[index + 1]; RS value2 = b.getSparseElement(index + 1); if (i2 != j2) { int ij = i2 + ans.getColumnSize() * j2; int ji = j2 + ans.getColumnSize() * i2; ans.denseElements[ij] = ans.denseElements[ij].add(value2); ans.denseElements[ji] = ans.denseElements[ji].add(value2); } else { int ii = i2 + ans.getColumnSize() * i2; ans.denseElements[ii] = ans.denseElements[ii].add(value2); } int i3 = b.rowIndex[index + 2]; int j3 = b.columnIndex[index + 2]; RS value3 = b.getSparseElement(index + 2); if (i3 != j3) { int ij = i3 + ans.getColumnSize() * j3; int ji = j3 + ans.getColumnSize() * i3; ans.denseElements[ij] = ans.denseElements[ij].add(value3); ans.denseElements[ji] = ans.denseElements[ji].add(value3); } else { int ii = i3 + ans.getColumnSize() * i3; ans.denseElements[ii] = ans.denseElements[ii].add(value3); } int i4 = b.rowIndex[index + 3]; int j4 = b.columnIndex[index + 3]; RS value4 = b.getSparseElement(index + 3); if (i4 != j4) { int ij = i4 + ans.getColumnSize() * j4; int ji = j4 + ans.getColumnSize() * i4; ans.denseElements[ij] = ans.denseElements[ij].add(value4); ans.denseElements[ji] = ans.denseElements[ji].add(value4); } else { int ii = i4 + ans.getColumnSize() * i4; ans.denseElements[ii] = ans.denseElements[ii].add(value4); } } return ans; case DENSE: int length = ans.getRowSize() * ans.getColumnSize(); BLAS.dxpy(length, b.denseElements, 1, ans.denseElements, 1); return ans; case DIAGONAL: BLAS.dxpy(ans.getColumnSize(), b.diagonalElements, 1, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * ans = a - b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> minus(DenseMatrix<RS,RM,CS,CM> a, SparseMatrix<RS,RM,CS,CM> b) { if (a.getRowSize() != b.getRowSize() || a.getColumnSize() != b.getColumnSize()) { throw new RuntimeException("minus :: different matrix size"); //$NON-NLS-1$ } DenseMatrix<RS,RM,CS,CM> ans = a.createClone(); switch (b.getSparseOrDenseOrDiagonal()) { case SPARSE: int shou = b.nonZeroCount / 4; int amari = b.nonZeroCount % 4; for (int index = 0; index < amari; ++index) { int i = b.rowIndex[index]; int j = b.columnIndex[index]; RS value = b.getSparseElement(index); if (i != j) { int ij = i + ans.getColumnSize() * j; int ji = j + ans.getColumnSize() * i; ans.denseElements[ij] = ans.denseElements[ij].subtract(value); ans.denseElements[ji] = ans.denseElements[ji].subtract(value); } else { int ii = i + ans.getColumnSize() * i; ans.denseElements[ii] = ans.denseElements[ii].subtract(value); } } int index; int counter; for (index = amari, counter = 0; counter < shou; ++counter, index += 4) { int i1 = b.rowIndex[index]; int j1 = b.columnIndex[index]; RS value1 = b.getSparseElement(index); if (i1 != j1) { int ij = i1 + ans.getColumnSize() * j1; int ji = j1 + ans.getColumnSize() * i1; ans.denseElements[ij] = ans.denseElements[ij].subtract(value1); ans.denseElements[ji] = ans.denseElements[ji].subtract(value1); } else { int ii = i1 + ans.getColumnSize() * i1; ans.denseElements[ii] = ans.denseElements[ii].subtract(value1); } int i2 = b.rowIndex[index + 1]; int j2 = b.columnIndex[index + 1]; RS value2 = b.getSparseElement(index + 1); if (i2 != j2) { int ij = i2 + ans.getColumnSize() * j2; int ji = j2 + ans.getColumnSize() * i2; ans.denseElements[ij] = ans.denseElements[ij].subtract(value2); ans.denseElements[ji] = ans.denseElements[ji].subtract(value2); } else { int ii = i2 + ans.getColumnSize() * i2; ans.denseElements[ii] = ans.denseElements[ii].subtract(value2); } int i3 = b.rowIndex[index + 2]; int j3 = b.columnIndex[index + 2]; RS value3 = b.getSparseElement(index + 2); if (i3 != j3) { int ij = i3 + ans.getColumnSize() * j3; int ji = j3 + ans.getColumnSize() * i3; ans.denseElements[ij] = ans.denseElements[ij].subtract(value3); ans.denseElements[ji] = ans.denseElements[ji].subtract(value3); } else { int ii = i3 + ans.getColumnSize() * i3; ans.denseElements[ii] = ans.denseElements[ii].subtract(value3); } int i4 = b.rowIndex[index + 3]; int j4 = b.columnIndex[index + 3]; RS value4 = b.getSparseElement(index + 3); if (i4 != j4) { int ij = i4 + ans.getColumnSize() * j4; int ji = j4 + ans.getColumnSize() * i4; ans.denseElements[ij] = ans.denseElements[ij].subtract(value4); ans.denseElements[ji] = ans.denseElements[ji].subtract(value4); } else { int ii = i4 + ans.getColumnSize() * i4; ans.denseElements[ii] = ans.denseElements[ii].subtract(value4); } } return ans; case DENSE: int length = ans.getRowSize() * ans.getColumnSize(); BLAS.dxmy(length, b.denseElements, 1, ans.denseElements, 1); return ans; case DIAGONAL: BLAS.dxmy(ans.getColumnSize(), b.diagonalElements, 1, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * ans = a + b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param b b * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockVector<RS,RM,CS,CM> plus(BlockVector<RS,RM,CS,CM> a, BlockVector<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("plus:: different nBlock size"); //$NON-NLS-1$ } RS unit = a.getElementUnit(); BlockVector<RS,RM,CS,CM> ans = new BlockVector<>(a.getBlockSize(), a.getBlockStructs(), unit); for (int i = 0; i < a.getBlockSize(); ++i) { Vector<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * ans = a + b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param b b * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockVector<RS,RM,CS,CM> plus(BlockVector<RS,RM,CS,CM> a, BlockVector<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("plus:: different nBlock size"); //$NON-NLS-1$ } RS unit = a.getElementUnit(); BlockVector<RS,RM,CS,CM> ans = new BlockVector<>(a.getBlockSize(), a.getBlockStructs(), unit); for (int i = 0; i < a.getBlockSize(); ++i) { Vector<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans = a + b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("plus:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * ans = a + b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("plus:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans = a - b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> minus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("minus:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = minus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans = a + b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockSparseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("plus:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(b.getBlockSize(), b.getBlockStructs(), b.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * ans = a + b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockSparseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("plus:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(b.getBlockSize(), b.getBlockStructs(), b.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans = a - b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> minus(BlockSparseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("minus:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(b.getBlockSize(), b.getBlockStructs(), b.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = minus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans + a * b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockSparseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("plus:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * ans = a + b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockSparseMatrix<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("plus:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans = a - b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> minus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockSparseMatrix<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("minus:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = minus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans = a '*' (*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param operator 演算子 * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> Vector<RS,RM,CS,CM> let(Vector<RS,RM,CS,CM> a, final char operator, RS scalar) { switch (operator) { case '*': Vector<RS,RM,CS,CM> ans = multiply(a, scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '*' (*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param operator 演算子 * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockVector<RS,RM,CS,CM> let(BlockVector<RS,RM,CS,CM> a, final char operator, RS scalar) { switch (operator) { case '*': BlockVector<RS,RM,CS,CM> ans = multiply(a, scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '*' (*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockDenseMatrix<RS,RM,CS,CM> a, final char operator, RS scalar) { switch (operator) { case '*': BlockDenseMatrix<RS,RM,CS,CM> ans = multiply(a, scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param operator 演算子 * @param b b * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> Vector<RS,RM,CS,CM> let(Vector<RS,RM,CS,CM> a, final char operator, Vector<RS,RM,CS,CM> b, RS scalar) { Vector<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b, scalar); return ans; case '-': final RS minus_scalar = scalar.unaryMinus(); ans = plus(a, b, minus_scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param operator 演算子 * @param b b * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> Vector<RS,RM,CS,CM> let(Vector<RS,RM,CS,CM> a, final char operator, Vector<RS,RM,CS,CM> b) { Vector<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b); return ans; case '-': ans = minus(a, b); //final RS unit = a.getElementUnit(); //final RS minus_scalar = unit.create(-1); //ans = plus(a, b, minus_scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' 't' 'T' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> let(DenseMatrix<RS,RM,CS,CM> a, final char operator, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { DenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b, scalar); return ans; case '-': final RS minus_scalar = scalar.unaryMinus(); ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b, scalar); return ans; case 't': // ret = aMat**T * bMat ans = tran_multiply(a, b, scalar); return ans; case 'T': // ret = aMat * bMat**T ans = multiply_tran(a, b, scalar); return ans; default: throw new IllegalArgumentException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' 't' 'T' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> let(DenseMatrix<RS,RM,CS,CM> a, final char operator, DenseMatrix<RS,RM,CS,CM> b) { DenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b); return ans; case '-': ans = minus(a, b); //final RS unit = a.getElementUnit(); //final RS minus_scalar = unit.create(-1); //ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b); return ans; case 't': // ret = aMat**T * bMat ans = tran_multiply(a, b); return ans; case 'T': // ret = aMat * bMat**T ans = multiply_tran(a, b); return ans; default: throw new IllegalArgumentException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> let(SparseMatrix<RS,RM,CS,CM> a, final char operator, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { DenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b, scalar); return ans; case '-': final RS minus_scalar = scalar.unaryMinus(); ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b, scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> let(SparseMatrix<RS,RM,CS,CM> a, final char operator, DenseMatrix<RS,RM,CS,CM> b) { DenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b); return ans; case '-': ans = minus(a, b); //final RS unit = a.getElementUnit(); //final RS minus_scalar = unit.create(-1); //ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> let(DenseMatrix<RS,RM,CS,CM> a, final char operator, SparseMatrix<RS,RM,CS,CM> b, RS scalar) { DenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b, scalar); return ans; case '-': final RS minus_scalar = scalar.unaryMinus(); ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b, scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> let(DenseMatrix<RS,RM,CS,CM> a, final char operator, SparseMatrix<RS,RM,CS,CM> b) { DenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b); return ans; case '-': ans = minus(a, b); //final RS unit = a.getElementUnit(); //final RS minus_scalar = unit.create(-1); //ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' 't' 'T' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockDenseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { BlockDenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b, scalar); return ans; case '-': final RS minus_scalar = scalar.unaryMinus(); ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b, scalar); return ans; case 't': // ret = aMat**T * bMat ans = tran_multiply(a, b, scalar); return ans; case 'T': // ret = aMat * bMat**T ans = multiply_tran(a, b, scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' 't' 'T' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockDenseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b) { BlockDenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b); return ans; case '-': ans = minus(a, b); //final RS unit = a.getElementUnit(); //final RS minus_scalar = unit.create(-1); //ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b); return ans; case 't': // ret = aMat**T * bMat ans = tran_multiply(a, b); return ans; case 'T': // ret = aMat * bMat**T ans = multiply_tran(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockSparseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { BlockDenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b, scalar); return ans; case '-': final RS minus_scalar = scalar.unaryMinus(); ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b, scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockSparseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b) { BlockDenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b); return ans; case '-': ans = minus(a, b); //final RS unit = a.getElementUnit(); //final RS minus_scalar = unit.create(-1); //ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockDenseMatrix<RS,RM,CS,CM> a, final char operator, BlockSparseMatrix<RS,RM,CS,CM> b, RS scalar) { BlockDenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b, scalar); return ans; case '-': final RS minus_scalar = scalar.unaryMinus(); ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b, scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockDenseMatrix<RS,RM,CS,CM> a, final char operator, BlockSparseMatrix<RS,RM,CS,CM> b) { BlockDenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b); return ans; case '-': ans = minus(a, b); //final RS unit = a.getElementUnit(); //final RS minus_scalar = unit.create(-1); //ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = aMat '*' '/' bVec * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b b * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> Vector<RS,RM,CS,CM> let(DenseMatrix<RS,RM,CS,CM> a, final char operator, Vector<RS,RM,CS,CM> b) { Vector<RS,RM,CS,CM> ans; switch (operator) { case '*': ans = multiply(a, b); return ans; case '/': // ret = aMat^{-1} * bVec; // aMat is positive definite and already cholesky factorized. ans = solveSystems(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = inner_product(a,b) // op = '.' * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param operator 演算子 * @param b b * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(Vector<RS,RM,CS,CM> a, final char operator, Vector<RS,RM,CS,CM> b) { switch (operator) { case '.': RS ans = getInnerProduct(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = inner_product(a,b) // op = '.' * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(DenseMatrix<RS,RM,CS,CM> a, final char operator, DenseMatrix<RS,RM,CS,CM> b) { switch (operator) { case '.': RS ans = getInnerProduct(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = inner_product(a,b) // op = '.' * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(DenseMatrix<RS,RM,CS,CM> a, final char operator, SparseMatrix<RS,RM,CS,CM> b) { switch (operator) { case '.': RS ans = getInnerProduct(b, a); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = inner_product(a,b) // op = '.' * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(SparseMatrix<RS,RM,CS,CM> a, final char operator, DenseMatrix<RS,RM,CS,CM> b) { switch (operator) { case '.': RS ans = getInnerProduct(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = inner_product(a,b) // op = '.' * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param operator 演算子 * @param b b * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(BlockVector<RS,RM,CS,CM> a, final char operator, BlockVector<RS,RM,CS,CM> b) { switch (operator) { case '.': RS ans = getInnerProduct(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = inner_product(a,b) // op = '.' * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(BlockDenseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b) { switch (operator) { case '.': RS ans = getInnerProduct(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = inner_product(a,b) // op = '.' * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(BlockSparseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b) { switch (operator) { case '.': RS ans = getInnerProduct(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = inner_product(a,b) // op = '.' * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(BlockDenseMatrix<RS,RM,CS,CM> a, final char operator, BlockSparseMatrix<RS,RM,CS,CM> b) { switch (operator) { case '.': RS ans = getInnerProduct(b, a); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } } |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 149 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 192 |
for (int i = 0; i < a.getBlockSize(); ++i) { ret = ret.add(getInnerProduct(a.getBlock(i), b.getBlock(i))); } return ret; } /** * 内積の計算を行います。 AI.getInnerProduct(ret,aVec,bVec)をAI.ret=getInnerProduct(aVec,bVec)に変更。 * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return aMat bMatの内積 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS getInnerProduct(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { if (a.getRowSize() != b.getRowSize() || a.getColumnSize() != b.getColumnSize()) { throw new RuntimeException("getInnerProduct:: different memory size"); //$NON-NLS-1$ } switch (a.getDenseOrDiagonal()) { case DENSE: int length = a.getRowSize() * a.getColumnSize(); return BLAS.<RS,RM,CS,CM> ddot(length, a.denseElements, 1, b.denseElements, 1); case DIAGONAL: return BLAS.ddot(a.getColumnSize(), a.diagonalElements, 1, b.diagonalElements, 1); default: throw new IllegalArgumentException(); } } /** * 内積の計算を行います。 Al.getInnerProduct(ret,aVec,bVec)をret=Al.getInnerProduct(aVec,bVec)に変更。 * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 内積 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS getInnerProduct(SparseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { if (a.getRowSize() != b.getRowSize() || a.getColumnSize() != b.getColumnSize()) { throw new RuntimeException("getInnerProduct:: different memory size"); //$NON-NLS-1$ } final RS unit = b.getElementUnit(); int index = 0; int counter = 0; RS ans; switch (a.getSparseOrDenseOrDiagonal()) { case SPARSE: // Attension: in SPARSE case, only half elements // are stored. And bMat must be DENSE case. ans = unit.create(0); int amari = a.nonZeroCount % 4; int shou = a.nonZeroCount / 4; for (index = 0; index < amari; ++index) { int i = a.rowIndex[index]; int j = a.columnIndex[index]; RS value = a.getSparseElement(index); if (i == j) { ans = ans.add(value.multiply(b.denseElements[i + b.getRowSize() * j])); } else { ans = ans.add(value.multiply((b.denseElements[i + b.getRowSize() * j].add(b.denseElements[j + b.getRowSize() * i])))); } } index = amari; counter = 0; for (counter = 0; counter < shou; ++counter) { int i1 = a.rowIndex[index]; int j1 = a.columnIndex[index]; RS value1 = a.getSparseElement(index); RS ans1; if (i1 == j1) { ans1 = value1.multiply(b.denseElements[i1 + b.getRowSize() * j1]); } else { ans1 = value1.multiply((b.denseElements[i1 + b.getRowSize() * j1].add(b.denseElements[j1 + b.getRowSize() * i1]))); } int i2 = a.rowIndex[index + 1]; int j2 = a.columnIndex[index + 1]; RS value2 = a.getSparseElement(index + 1); RS ans2; if (i2 == j2) { ans2 = value2.multiply(b.denseElements[i2 + b.getRowSize() * j2]); } else { ans2 = value2.multiply((b.denseElements[i2 + b.getRowSize() * j2].add(b.denseElements[j2 + b.getRowSize() * i2]))); } int i3 = a.rowIndex[index + 2]; int j3 = a.columnIndex[index + 2]; RS value3 = a.getSparseElement(index + 2); RS ans3; if (i3 == j3) { ans3 = value3.multiply(b.denseElements[i3 + b.getRowSize() * j3]); } else { ans3 = value3.multiply((b.denseElements[i3 + b.getRowSize() * j3].add(b.denseElements[j3 + b.getRowSize() * i3]))); } int i4 = a.rowIndex[index + 3]; int j4 = a.columnIndex[index + 3]; RS value4 = a.getSparseElement(index + 3); RS ans4; if (i4 == j4) { ans4 = value4.multiply(b.denseElements[i4 + b.getRowSize() * j4]); } else { ans4 = value4.multiply((b.denseElements[i4 + b.getRowSize() * j4].add(b.denseElements[j4 + b.getRowSize() * i4]))); } index += 4; ans = ans.add(ans1.add(ans2).add(ans3).add(ans4)); //20090120修正したけど 不具合でたらここもチェックで。 } return ans; case DENSE: int length = a.getRowSize() * a.getColumnSize(); return BLAS.ddot(length, a.denseElements, 1, b.denseElements, 1); case DIAGONAL: return BLAS.ddot(a.getColumnSize(), a.diagonalElements, 1, b.diagonalElements, 1); default: throw new IllegalArgumentException(); } } /** * 内積の計算を行います Al.getInnerProduct(ret,aVec,bVec)をret=Al.getInnerProduct(aVec,bVec)に変更。 * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 内積 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS getInnerProduct(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("getInnerProduct:: different memory size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); RS ans = unit.create(0); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1898 |
org/mklab/sdpj/algebra/Algebra.java | 2010 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2032 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2144 |
if (ans.isDense() == false || b.isDense() == false) { throw new RuntimeException("plus :: different matrix type"); //$NON-NLS-1$ } int shou = a.nonZeroCount / 4; int amari = a.nonZeroCount % 4; for (int index = 0; index < amari; ++index) { int i = a.rowIndex[index]; int j = a.columnIndex[index]; RS value = a.getSparseElement(index); if (i != j) { int ij = i + ans.getColumnSize() * j; int ji = j + ans.getColumnSize() * i; ans.denseElements[ij] = ans.denseElements[ij].add(value); ans.denseElements[ji] = ans.denseElements[ji].add(value); } else { int ii = i + ans.getColumnSize() * i; ans.denseElements[ii] = ans.denseElements[ii].add(value); } } int index; int counter; for (index = amari, counter = 0; counter < shou; ++counter, index += 4) { int i1 = a.rowIndex[index]; int j1 = a.columnIndex[index]; RS value1 = a.getSparseElement(index); if (i1 != j1) { int ij = i1 + ans.getColumnSize() * j1; int ji = j1 + ans.getColumnSize() * i1; ans.denseElements[ij] = ans.denseElements[ij].add(value1); ans.denseElements[ji] = ans.denseElements[ji].add(value1); } else { int ii = i1 + ans.getColumnSize() * i1; ans.denseElements[ii] = ans.denseElements[ii].add(value1); } int i2 = a.rowIndex[index + 1]; int j2 = a.columnIndex[index + 1]; RS value2 = a.getSparseElement(index + 1); if (i2 != j2) { int ij = i2 + ans.getColumnSize() * j2; int ji = j2 + ans.getColumnSize() * i2; ans.denseElements[ij] = ans.denseElements[ij].add(value2); ans.denseElements[ji] = ans.denseElements[ji].add(value2); } else { int ii = i2 + ans.getColumnSize() * i2; ans.denseElements[ii] = ans.denseElements[ii].add(value2); } int i3 = a.rowIndex[index + 2]; int j3 = a.columnIndex[index + 2]; RS value3 = a.getSparseElement(index + 2); if (i3 != j3) { int ij = i3 + ans.getColumnSize() * j3; int ji = j3 + ans.getColumnSize() * i3; ans.denseElements[ij] = ans.denseElements[ij].add(value3); ans.denseElements[ji] = ans.denseElements[ji].add(value3); } else { int ii = i3 + ans.getColumnSize() * i3; ans.denseElements[ii] = ans.denseElements[ii].add(value3); } int i4 = a.rowIndex[index + 3]; int j4 = a.columnIndex[index + 3]; RS value4 = a.getSparseElement(index + 3); if (i4 != j4) { int ij = i4 + ans.getColumnSize() * j4; int ji = j4 + ans.getColumnSize() * i4; ans.denseElements[ij] = ans.denseElements[ij].add(value4); ans.denseElements[ji] = ans.denseElements[ji].add(value4); } else { int ii = i4 + ans.getColumnSize() * i4; ans.denseElements[ii] = ans.denseElements[ii].add(value4); } } return ans; case DENSE: if (ans.isDense() == false || b.isDense() == false) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 27 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 37 |
public class Algebra<RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> { /** * 最小固有値の計算を行います aMat is rewritten. aMat must be symmetric. eigenVec is the space of eigen values and needs memory of length aMat.nRow workVec is temporary space and needs 3*aMat.nRow-1 length * memory. * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param eigenValues 固有値 * @param workVec 作業領域 * @return 最小固有値 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS getMinEigenValue(DenseMatrix<RS,RM,CS,CM> a, Vector<RS,RM,CS,CM> eigenValues, Vector<RS,RM,CS,CM> workVec) { final RS unit = a.getElementUnit(); int n = a.getRowSize(); switch (a.getDenseOrDiagonal()) { case DENSE: int lwork = 3 * n - 1; // "N" means that we need not eigen vectors // "L" means that we refer only lower triangular. int info = Clapack.dsyev("NonVectors", "Lower", n, a.denseElements, n, eigenValues.getElements(), workVec.getElements(), lwork); //$NON-NLS-1$ //$NON-NLS-2$ if (info != 0) { return unit.createZero(); } return eigenValues.getElements()[0]; case DIAGONAL: RS minimumEigenValue = a.diagonalElements[0]; eigenValues.getElements()[0] = a.diagonalElements[0]; for (int i = 1; i < n; ++i) { eigenValues.getElements()[i] = a.diagonalElements[i]; if (a.diagonalElements[i].isLessThan(minimumEigenValue)) { minimumEigenValue = a.diagonalElements[i]; } } return minimumEigenValue; default: throw new IllegalArgumentException(); } } /** * 最小固有値の計算を行います。 * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param eigenVec 固有ベクトル * @param workVec 作業領域 * @return 最小固有値 */ static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS getMinEigenValue(BlockDenseMatrix<RS,RM,CS,CM> a, BlockVector<RS,RM,CS,CM> eigenVec, BlockVector<RS,RM,CS,CM> workVec) { int n = a.getBlock(0).getRowSize(); if (eigenVec.getBlock(0).getDimension() != n) { throw new RuntimeException("getMinEigenValue:: different memory size"); //$NON-NLS-1$ } if (workVec.getBlock(0).getDimension() != 3 * n - 1) { throw new RuntimeException("getMinEigenValue:: different memory size"); //$NON-NLS-1$ } RS min_eigen = getMinEigenValue(a.getBlock(0), eigenVec.getBlock(0), workVec.getBlock(0)); for (int l = 1; l < a.getBlockSize(); ++l) { n = a.getBlock(l).getRowSize(); if (eigenVec.getBlock(l).getDimension() != n) { throw new RuntimeException("getMinEigenValue:: different memory size"); //$NON-NLS-1$ } if (workVec.getBlock(l).getDimension() != 3 * n - 1) { throw new RuntimeException("getMinEigenValue:: different memory size"); //$NON-NLS-1$ } RS tmp_eigen = getMinEigenValue(a.getBlock(l), eigenVec.getBlock(l), workVec.getBlock(l)); if (tmp_eigen.isLessThan(min_eigen)) { min_eigen = tmp_eigen; } } return min_eigen; } /** * 内積の計算を行います。 * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param b b * @return aVecとbVecの内積 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS getInnerProduct(Vector<RS,RM,CS,CM> a, Vector<RS,RM,CS,CM> b) { int size = a.getDimension(); if (size != b.getDimension()) { throw new RuntimeException("getInnerProduct:: different memory size"); //$NON-NLS-1$ } |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 764 |
org/mklab/sdpj/algebra/Algebra.java | 849 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 898 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 983 |
RS value = a.getSparseElement(index).multiply(scalar); if (i != j) { RS[] bMat_j = unit.createArray(b.denseElements.length - j); System.arraycopy(b.denseElements, j, bMat_j, 0, bMat_j.length); RS[] retMat_i = unit.createArray(ans.denseElements.length - i); System.arraycopy(ans.denseElements, i, retMat_i, 0, retMat_i.length); BLAS.daxpy(b.getColumnSize(), value, bMat_j, b.getRowSize(), retMat_i, ans.getRowSize()); System.arraycopy(retMat_i, 0, ans.denseElements, i, retMat_i.length); RS[] bMat_i = unit.createArray(b.denseElements.length - i); System.arraycopy(b.denseElements, i, bMat_i, 0, bMat_i.length); RS[] retMat_j = unit.createArray(ans.denseElements.length - j); System.arraycopy(ans.denseElements, j, retMat_j, 0, retMat_j.length); BLAS.daxpy(b.getColumnSize(), value, bMat_i, b.getRowSize(), retMat_j, ans.getRowSize()); System.arraycopy(retMat_j, 0, ans.denseElements, j, retMat_j.length); } else { RS[] bMat_j = unit.createArray(b.denseElements.length - j); System.arraycopy(b.denseElements, j, bMat_j, 0, bMat_j.length); RS[] retMat_j = unit.createArray(ans.denseElements.length - j); System.arraycopy(ans.denseElements, j, retMat_j, 0, retMat_j.length); BLAS.daxpy(b.getColumnSize(), value, bMat_j, b.getRowSize(), retMat_j, ans.getRowSize()); System.arraycopy(retMat_j, 0, ans.denseElements, j, retMat_j.length); } } return ans; case DENSE: if (ans.isDense() == false || b.isDense() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } BLAS.dgemm( "NoTranspose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), scalar, a.denseElements, a.getRowSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ |
File | Line |
---|---|
org/mklab/sdpj/gpack/blaswrap/Dtrmm.java | 16 |
org/mklab/sdpj/gpack/blaswrap/Dtrsm.java | 17 |
public class Dtrmm<RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> { /* Purpose ======= DTRMM performs one of the matrix-matrix operations B := alpha*op( A )*B, or B := alpha*B*op( A ), where alpha is a scalar, B is an m by n matrix, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A'. Parameters ========== SIDE - CHARACTER*1. On entry, SIDE specifies whether op( A ) multiplies B from the left or right as follows: SIDE = 'L' or 'l' B := alpha*op( A )*B. SIDE = 'R' or 'r' B := alpha*B*op( A ). Unchanged on exit. UPLO - CHARACTER*1. On entry, UPLO specifies whether the matrix A is an upper or lower triangular matrix as follows: UPLO = 'U' or 'u' A is an upper triangular matrix. UPLO = 'L' or 'l' A is a lower triangular matrix. Unchanged on exit. TRANSA - CHARACTER*1. On entry, TRANSA specifies the form of op( A ) to be used in the matrix multiplication as follows: TRANSA = 'N' or 'n' op( A ) = A. TRANSA = 'T' or 't' op( A ) = A'. TRANSA = 'C' or 'c' op( A ) = A'. Unchanged on exit. DIAG - CHARACTER*1. On entry, DIAG specifies whether or not A is unit triangular as follows: DIAG = 'U' or 'u' A is assumed to be unit triangular. DIAG = 'N' or 'n' A is not assumed to be unit triangular. Unchanged on exit. M - INTEGER. On entry, M specifies the number of rows of B. M must be at least zero. Unchanged on exit. N - INTEGER. On entry, N specifies the number of columns of B. N must be at least zero. Unchanged on exit. ALPHA - DOUBLE PRECISION. On entry, ALPHA specifies the scalar alpha. When alpha is zero then A is not referenced and B need not be set before entry. Unchanged on exit. A - DOUBLE PRECISION array of DIMENSION ( LDA, k ), where k is m when SIDE = 'L' or 'l' and is n when SIDE = 'R' or 'r'. Before entry with UPLO = 'U' or 'u', the leading k by k upper triangular part of the array A must contain the upper triangular matrix and the strictly lower triangular part of A is not referenced. Before entry with UPLO = 'L' or 'l', the leading k by k lower triangular part of the array A must contain the lower triangular matrix and the strictly upper triangular part of A is not referenced. Note that when DIAG = 'U' or 'u', the diagonal elements of A are not referenced either, but are assumed to be unity. Unchanged on exit. LDA - INTEGER. On entry, LDA specifies the first dimension of A as declared in the calling (sub) program. When SIDE = 'L' or 'l' then LDA must be at least max( 1, m ), when SIDE = 'R' or 'r' then LDA must be at least max( 1, n ). Unchanged on exit. B - DOUBLE PRECISION array of DIMENSION ( LDB, n ). Before entry, the leading m by n part of the array B must contain the matrix B, and on exit is overwritten by the transformed matrix. LDB - INTEGER. On entry, LDB specifies the first dimension of B as declared in the calling (sub) program. LDB must be at least max( 1, m ). Unchanged on exit. Level 3 Blas routine. -- Written on 8-February-1989. Jack Dongarra, Argonne National Laboratory. Iain Duff, AERE Harwell. Jeremy Du Croz, Numerical Algorithms Group Ltd. Sven Hammarling, Numerical Algorithms Group Ltd. Test the input parameters. Parameter adjustments */ /** * @param side side * @param uplo uplo * @param transa transa * @param diag diag * @param m m * @param n n * @param alpha alpha * @param a a * @param lda lda * @param b b * @param ldb ldb * @return result */ public int execute(String side, String uplo, String transa, String diag, int m, int n, RS alpha, RS[] a, int lda, RS[] b, int ldb) { final RS unit = a[0].createUnit(); int a_dim1 = lda; int a_offset = 1 + a_dim1 * 1; int pointer_a = -a_offset; int b_dim1 = ldb; int b_offset = 1 + b_dim1 * 1; int pointer_b = -b_offset; boolean lside = BLAS.lsame(side, "L"); //$NON-NLS-1$ int nrowa; if (lside) { nrowa = m; } else { nrowa = n; } boolean nounit = BLAS.lsame(diag, "N"); //$NON-NLS-1$ boolean upper = BLAS.lsame(uplo, "U"); //$NON-NLS-1$ int info = 0; if (!lside && !BLAS.lsame(side, "R")) { //$NON-NLS-1$ info = 1; } else if (!upper && !BLAS.lsame(uplo, "L")) { //$NON-NLS-1$ info = 2; } else if (!BLAS.lsame(transa, "N") && !BLAS.lsame(transa, "T") && !BLAS.lsame(transa, "C")) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ info = 3; } else if (!BLAS.lsame(diag, "U") && !BLAS.lsame(diag, "N")) { //$NON-NLS-1$ //$NON-NLS-2$ info = 4; } else if (m < 0) { info = 5; } else if (n < 0) { info = 6; } else if (lda < Math.max(1, nrowa)) { info = 9; } else if (ldb < Math.max(1, m)) { info = 11; } if (info != 0) { BLAS.xerbla("DTRMM ", info); //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 670 |
org/mklab/sdpj/algebra/Algebra.java | 1461 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 804 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1595 |
"NoTranspose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), scalar, a.denseElements, a.getRowSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = scalar.multiply(a.diagonalElements[j].multiply(b.diagonalElements[j])); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = scalar.multiply(a.diagonalElements[j].multiply(b.diagonalElements[j])); ans.diagonalElements[j + 1] = scalar.multiply(a.diagonalElements[j + 1].multiply(b.diagonalElements[j + 1])); ans.diagonalElements[j + 2] = scalar.multiply(a.diagonalElements[j + 2].multiply(b.diagonalElements[j + 2])); ans.diagonalElements[j + 3] = scalar.multiply(a.diagonalElements[j + 3].multiply(b.diagonalElements[j + 3])); } return ans; default: throw new IllegalArgumentException(); } } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/blaswrap/Dsyr2k.java | 177 |
org/mklab/sdpj/gpack/blaswrap/Dsyrk.java | 151 |
if (n == 0 || (alpha.isZero() || k == 0) && beta.equals(unit.create(1))) { return 0; } // And when alpha.eq.zero. if (alpha.isZero()) { if (upper) { if (beta.isZero()) { for (int j = 1; j <= n; ++j) { for (int i = 1; i <= j; ++i) { c[j * c_dim1 + i + pointer_c] = unit.createZero(); } } } else { for (int j = 1; j <= n; ++j) { for (int i = 1; i <= j; ++i) { int p = j * c_dim1 + i + pointer_c; c[p] = beta.multiply(c[p]); } } } } else { if (beta.isZero()) { for (int j = 1; j <= n; ++j) { for (int i = j; i <= n; ++i) { c[j * c_dim1 + i + pointer_c] = unit.createZero(); } } } else { for (int j = 1; j <= n; ++j) { for (int i = j; i <= n; ++i) { int p = j * c_dim1 + i + pointer_c; c[p] = beta.multiply(c[p]); } } } } return 0; } if (BLAS.lsame(trans, "N")) { //$NON-NLS-1$ // Form C := alpha*A*B' + alpha*B*A' + C. if (upper) { for (int j = 1; j <= n; ++j) { if (beta.isZero()) { for (int i = 1; i <= j; ++i) { c[j * c_dim1 + i + pointer_c] = unit.createZero(); } } else if (!beta.equals(unit.createUnit())) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 670 |
org/mklab/sdpj/algebra/Algebra.java | 1461 |
org/mklab/sdpj/algebra/Algebra.java | 1603 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 804 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1595 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1737 |
"NoTranspose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), scalar, a.denseElements, a.getRowSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = scalar.multiply(a.diagonalElements[j].multiply(b.diagonalElements[j])); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = scalar.multiply(a.diagonalElements[j].multiply(b.diagonalElements[j])); ans.diagonalElements[j + 1] = scalar.multiply(a.diagonalElements[j + 1].multiply(b.diagonalElements[j + 1])); ans.diagonalElements[j + 2] = scalar.multiply(a.diagonalElements[j + 2].multiply(b.diagonalElements[j + 2])); ans.diagonalElements[j + 3] = scalar.multiply(a.diagonalElements[j + 3].multiply(b.diagonalElements[j + 3])); } return ans; default: throw new IllegalArgumentException(); } } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 713 |
org/mklab/sdpj/algebra/Algebra.java | 1507 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 847 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1641 |
"NoTranspose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), unit.create(1), a.denseElements, a.getRowSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = a.diagonalElements[j].multiply(b.diagonalElements[j]); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = a.diagonalElements[j].multiply(b.diagonalElements[j]); ans.diagonalElements[j + 1] = a.diagonalElements[j + 1].multiply(b.diagonalElements[j + 1]); ans.diagonalElements[j + 2] = a.diagonalElements[j + 2].multiply(b.diagonalElements[j + 2]); ans.diagonalElements[j + 3] = a.diagonalElements[j + 3].multiply(b.diagonalElements[j + 3]); } return ans; default: throw new IllegalArgumentException(); } } /** * Dense=Sparse*Dense * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply(SparseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1507 |
org/mklab/sdpj/algebra/Algebra.java | 1649 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1641 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1783 |
"Transpose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), unit.create(1), a.denseElements, a.getColumnSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = a.diagonalElements[j].multiply(b.diagonalElements[j]); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = a.diagonalElements[j].multiply(b.diagonalElements[j]); ans.diagonalElements[j + 1] = a.diagonalElements[j + 1].multiply(b.diagonalElements[j + 1]); ans.diagonalElements[j + 2] = a.diagonalElements[j + 2].multiply(b.diagonalElements[j + 2]); ans.diagonalElements[j + 3] = a.diagonalElements[j + 3].multiply(b.diagonalElements[j + 3]); } return ans; default: throw new IllegalArgumentException(); } } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> tran_multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 713 |
org/mklab/sdpj/algebra/Algebra.java | 1649 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 847 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1783 |
"NoTranspose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), unit.create(1), a.denseElements, a.getRowSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = a.diagonalElements[j].multiply(b.diagonalElements[j]); } int count; int j; for (j = amari, count = 0; count < shou; ++count, j += 4) { ans.diagonalElements[j] = a.diagonalElements[j].multiply(b.diagonalElements[j]); ans.diagonalElements[j + 1] = a.diagonalElements[j + 1].multiply(b.diagonalElements[j + 1]); ans.diagonalElements[j + 2] = a.diagonalElements[j + 2].multiply(b.diagonalElements[j + 2]); ans.diagonalElements[j + 3] = a.diagonalElements[j + 3].multiply(b.diagonalElements[j + 3]); } return ans; default: throw new IllegalArgumentException(); } } /** * Dense=Sparse*Dense * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply(SparseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 356 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 368 |
} else if (sname && LibF77.compare(c2, "OR", 2, 2) == 0) { //$NON-NLS-1$ if (c3[0] == 'G') { if (LibF77.compare(c4, "QR", 2, 2) == 0 || LibF77.compare(c4, "RQ", 2, 2) == 0 || LibF77.compare(c4, "LQ", 2, 2) == 0 || LibF77.compare(c4, "QL", 2, 2) == 0 || LibF77.compare(c4, "HR", 2, 2) == 0 || LibF77.compare(c4, "TR", 2, 2) == 0 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ || LibF77.compare(c4, "BR", 2, 2) == 0) { //$NON-NLS-1$ nb = 32; } } else if (c3[0] == 'M') { if (LibF77.compare(c4, "QR", 2, 2) == 0 || LibF77.compare(c4, "RQ", 2, 2) == 0 || LibF77.compare(c4, "LQ", 2, 2) == 0 || LibF77.compare(c4, "QL", 2, 2) == 0 || LibF77.compare(c4, "HR", 2, 2) == 0 || LibF77.compare(c4, "TR", 2, 2) == 0 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ || LibF77.compare(c4, "BR", 2, 2) == 0) { //$NON-NLS-1$ nb = 32; } } } else if (cname && LibF77.compare(c2, "UN", 2, 2) == 0) { //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 488 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 500 |
} else if (sname && LibF77.compare(c2, "OR", 2, 2) == 0) { //$NON-NLS-1$ if (c3[0] == 'G') { if (LibF77.compare(c4, "QR", 2, 2) == 0 || LibF77.compare(c4, "RQ", 2, 2) == 0 || LibF77.compare(c4, "LQ", 2, 2) == 0 || LibF77.compare(c4, "QL", 2, 2) == 0 || LibF77.compare(c4, "HR", 2, 2) == 0 || LibF77.compare(c4, "TR", 2, 2) == 0 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ || LibF77.compare(c4, "BR", 2, 2) == 0) { //$NON-NLS-1$ nbmin = 2; } } else if (c3[0] == 'M') { if (LibF77.compare(c4, "QR", 2, 2) == 0 || LibF77.compare(c4, "RQ", 2, 2) == 0 || LibF77.compare(c4, "LQ", 2, 2) == 0 || LibF77.compare(c4, "QL", 2, 2) == 0 || LibF77.compare(c4, "HR", 2, 2) == 0 || LibF77.compare(c4, "TR", 2, 2) == 0 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ || LibF77.compare(c4, "BR", 2, 2) == 0) { //$NON-NLS-1$ nbmin = 2; } } } else if (cname && LibF77.compare(c2, "UN", 2, 2) == 0) { //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/gpack/blaswrap/Dtrmv.java | 16 |
org/mklab/sdpj/gpack/blaswrap/Dtrsv.java | 17 |
public class Dtrmv<RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> { /* Purpose ======= DTRMV performs one of the matrix-vector operations x := A*x, or x := A'*x, where x is an n element vector and A is an n by n unit, or non-unit, upper or lower triangular matrix. Parameters ========== UPLO - CHARACTER*1. On entry, UPLO specifies whether the matrix is an upper or lower triangular matrix as follows: UPLO = 'U' or 'u' A is an upper triangular matrix. UPLO = 'L' or 'l' A is a lower triangular matrix. Unchanged on exit. TRANS - CHARACTER*1. On entry, TRANS specifies the operation to be performed as follows: TRANS = 'N' or 'n' x := A*x. TRANS = 'T' or 't' x := A'*x. TRANS = 'C' or 'c' x := A'*x. Unchanged on exit. DIAG - CHARACTER*1. On entry, DIAG specifies whether or not A is unit triangular as follows: DIAG = 'U' or 'u' A is assumed to be unit triangular. DIAG = 'N' or 'n' A is not assumed to be unit triangular. Unchanged on exit. N - INTEGER. On entry, N specifies the order of the matrix A. N must be at least zero. Unchanged on exit. A - DOUBLE PRECISION array of DIMENSION ( LDA, n ). Before entry with UPLO = 'U' or 'u', the leading n by n upper triangular part of the array A must contain the upper triangular matrix and the strictly lower triangular part of A is not referenced. Before entry with UPLO = 'L' or 'l', the leading n by n lower triangular part of the array A must contain the lower triangular matrix and the strictly upper triangular part of A is not referenced. Note that when DIAG = 'U' or 'u', the diagonal elements of A are not referenced either, but are assumed to be unity. Unchanged on exit. LDA - INTEGER. On entry, LDA specifies the first dimension of A as declared in the calling (sub) program. LDA must be at least max( 1, n ). Unchanged on exit. X - DOUBLE PRECISION array of dimension at least ( 1 + ( n - 1 )*abs( INCX ) ). Before entry, the incremented array X must contain the n element vector x. On exit, X is overwritten with the tranformed vector x. INCX - INTEGER. On entry, INCX specifies the increment for the elements of X. INCX must not be zero. Unchanged on exit. Level 2 Blas routine. -- Written on 22-October-1986. Jack Dongarra, Argonne National Lab. Jeremy Du Croz, Nag Central Office. Sven Hammarling, Nag Central Office. Richard Hanson, Sandia National Labs. Test the input parameters. Parameter adjustments */ /** * @param uplo uplo * @param trans trans * @param diag diag * @param n n * @param a a * @param lda lda * @param x x * @param incx incx * @return result */ public int execute(String uplo, String trans, String diag, int n, RS[] a, int lda, RS[] x, int incx) { int a_dim1 = lda; int a_offset = 1 + a_dim1 * 1; int pointer_a = -a_offset; int info = 0; if (!BLAS.lsame(uplo, "U") && !BLAS.lsame(uplo, "L")) { //$NON-NLS-1$ //$NON-NLS-2$ info = 1; } else if (!BLAS.lsame(trans, "N") && !BLAS.lsame(trans, "T") && !BLAS.lsame(trans, "C")) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ info = 2; } else if (!BLAS.lsame(diag, "U") && !BLAS.lsame(diag, "N")) { //$NON-NLS-1$ //$NON-NLS-2$ info = 3; } else if (n < 0) { info = 4; } else if (lda < Math.max(1, n)) { info = 6; } else if (incx == 0) { info = 8; } if (info != 0) { BLAS.xerbla("DTRMV ", info); //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/tool/Sedumi2.java | 115 |
org/mklab/sdpj/tool/Sedumi2.java | 216 |
Solver<MPFloat,MPFloatMatrix,MPFloatComplexNumber,MPFloatComplexMatrix> solver = new Solver<>(new MPFloat(1)); solver.setProblem(problem); solver.setOutFile("out.txt"); //$NON-NLS-1$ solver.setPrintStreamForDisplay(System.out); solver.run(); // solver.solve(problem, "out.txt", System.out, com); //$NON-NLS-1$ Solution<RS,RM,CS,CM> s = (Solution<RS, RM, CS, CM>)solver.getSolution(); MatxList ml = new MatxList(); Vector<RS,RM,CS,CM> y = s.getYvec(); ml.add(y.getElement(0).createGrid(y.getElements())); DenseMatrix<RS,RM,CS,CM> x = s.getXmat().getBlock(0); if (x.isDense()) { ml.add(x.denseElements[0].createGrid(x.denseElements)); } else { ml.add(x.diagonalElements[0].createGrid(x.diagonalElements)); } DenseMatrix<RS,RM,CS,CM> z = s.getZmat().getBlock(0); if (z.isDense()) { ml.add(z.denseElements[0].createGrid(z.denseElements)); } else { ml.add(z.diagonalElements[0].createGrid(z.diagonalElements)); } return ml; } |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dsteqr.java | 777 |
org/mklab/sdpj/gpack/lapackwrap/Dsterf.java | 480 |
} /** * @param type type * @param kl kl * @param ku ku * @param cfrom cfrom * @param cto cto * @param m m * @param n2 n2 * @param aIndex d * @param lda lda * @return result */ private int dlascl_d(String type, int kl, int ku, RS cfrom, RS cto, int m, int n2, int aIndex, int lda) { final RS unit = cfrom.createUnit(); RS[] aTemp = unit.createArray(this.d.length - aIndex); System.arraycopy(this.d, aIndex, aTemp, 0, aTemp.length); int info = Clapack.dlascl(type, kl, ku, cfrom, cto, m, n2, aTemp, lda); System.arraycopy(aTemp, 0, this.d, aIndex, aTemp.length); return info; } /** * @param type type * @param kl kl * @param ku ku * @param cfrom cfrom * @param cto cto * @param m m * @param n2 n2 * @param aIndex e * @param lda lda * @return result */ private int dlascl_e(String type, int kl, int ku, RS cfrom, RS cto, int m, int n2, int aIndex, int lda) { final RS unit = cfrom.createUnit(); RS[] aTemp = unit.createArray(this.e.length - aIndex); System.arraycopy(this.e, aIndex, aTemp, 0, aTemp.length); int info = Clapack.dlascl(type, kl, ku, cfrom, cto, m, n2, aTemp, lda); System.arraycopy(aTemp, 0, this.e, aIndex, aTemp.length); return info; } |
File | Line |
---|---|
org/mklab/sdpj/algorithm/StepLength.java | 129 |
org/mklab/sdpj/algorithm/StepLength.java | 209 |
this.dual = this.unit.create(9).divide(10); if (phase.getValue() == PhaseType.noINFO || phase.getValue() == PhaseType.dFEAS) { if (this.primal.isGreaterThan(1)) {// primal is infeasible this.primal = createUnit(); } } else {// when primal is feasible,check stepP1 is effective or not. RS incPrimalObj = Algebra.run(C, '.', newton.getDxMat()); if (incPrimalObj.isGreaterThan(0)) { if (this.primal.isGreaterThan(this.dual)) { this.primal = this.dual; } if (this.primal.isGreaterThan(1)) { this.primal = createUnit(); } } } if (phase.getValue() == PhaseType.noINFO || phase.getValue() == PhaseType.pFEAS) { if (this.dual.isGreaterThan(1)) { // dual is infeasible this.dual = createUnit(); } } else { // when dual is feasible,check stepD1 is effective or not. RS incDualObj = Algebra.run(b, '.', newton.getDyVec()); if (incDualObj.isLessThan(0)) { if (this.dual.isGreaterThan(this.primal)) { this.dual = this.primal; } if (this.dual.isGreaterThan(1)) { this.dual = createUnit(); } } } |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dlarfb.java | 317 |
org/mklab/sdpj/gpack/lapackwrap/Dlarfb.java | 574 |
this.arraycopyWorkTempOffsetForWork(); for (int j = 1; j <= k; ++j) { for (int i = 1; i <= m; ++i) { this.c[j * c_dim1 + i + pointer_c] = this.c[j * c_dim1 + i + pointer_c].subtract(this.work[j * work_dim1 + i + pointer_work]); /* L50: */ } /* L60: */ } } } else { /* Let V = ( V1 ) ( V2 ) (last K rows) where V2 is unit upper triangular. */ if (BLAS.lsame(side, "L")) { //$NON-NLS-1$ /* Form H * C or H' * C where C = ( C1 ) ( C2 ) W := C' * V = (C1'*V1 + C2'*V2) (stored in WORK) W := C2' */ for (int j = 1; j <= k; ++j) { RS[] cTemp = unit.createArray(n); RS[] workTemp = unit.createArray(n); System.arraycopy(this.c, c_dim1 + m - k + j + pointer_c, cTemp, 0, n); System.arraycopy(this.work, j * work_dim1 + 1 + pointer_work, workTemp, 0, n); BLAS.dcopy(n, cTemp, ldc, workTemp, 1); System.arraycopy(cTemp, 0, this.c, c_dim1 + m - k + j + pointer_c, n); System.arraycopy(workTemp, 0, this.work, j * work_dim1 + 1 + pointer_work, n); /* L70: */ } //配列をコピー work-->workTempOffset c-->cTempOffset this.arraycopyWorkForWorkTempOffset(); |
File | Line |
---|---|
org/mklab/sdpj/convert/SDPAM.java | 103 |
org/mklab/sdpj/convert/SDPAM.java | 174 |
public String getSDPADatSString() { final StringWriter sw = new StringWriter(); try (final PrintWriter pw = new PrintWriter(new BufferedWriter(sw))) { pw.print(this.mDIM); pw.println("=mDIM"); //$NON-NLS-1$ pw.print(this.nBLOCK); pw.println("=nBLOCK"); //$NON-NLS-1$ if (this.bLOCKsTRUCT.size() > 1) { pw.print("("); //$NON-NLS-1$ for (int i = 0; i < this.bLOCKsTRUCT.size(); i++) { pw.print(this.bLOCKsTRUCT.get(i)); if (i == this.bLOCKsTRUCT.size() - 1) { pw.print(")"); //$NON-NLS-1$ } else { pw.print(","); //$NON-NLS-1$ } } } else { pw.print(this.bLOCKsTRUCT.get(0)); } pw.println("=bLOCKsTRUCT"); //$NON-NLS-1$ pw.print("{"); //$NON-NLS-1$ for (int i = 0; i < this.c.length; i++) { pw.print(this.c[i]); if (i == this.c.length - 1) { pw.println("}"); //$NON-NLS-1$ } else { pw.print(","); //$NON-NLS-1$ } } int x = this.sdpamF[0].length; |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1301 |
org/mklab/sdpj/algebra/Algebra.java | 1399 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1435 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1533 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2603 |
org/mklab/sdpj/algebra/Algebra.java | 2759 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2737 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2893 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("plus:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * ans = a + b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dsteqr.java | 729 |
org/mklab/sdpj/gpack/lapackwrap/Dsterf.java | 522 |
} /** * @param id id * @param n n * @param dIndex dIndex * @return result */ private int dlasrt(String id, int n, int dIndex) { final RS unit = this.d[0].createUnit(); RS[] dTemp = unit.createArray(this.d.length - dIndex); System.arraycopy(this.d, dIndex, dTemp, 0, dTemp.length); int info = Clapack.dlasrt(id, n, dTemp); System.arraycopy(dTemp, 0, this.d, dIndex, dTemp.length); return info; } /** * @param norm input * @param n input * @param dIndex d input * @param eIndex e input * @return ans output */ private RS dlanst(String norm, int n, int dIndex, int eIndex) { final RS unit = this.d[0].createUnit(); RS[] dTemp = unit.createArray(this.d.length - dIndex); RS[] eTemp = unit.createArray(this.e.length - eIndex); System.arraycopy(this.d, dIndex, dTemp, 0, dTemp.length); System.arraycopy(this.e, eIndex, eTemp, 0, eTemp.length); return Clapack.dlanst(norm, n, dTemp, eTemp); |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dlasrt.java | 170 |
org/mklab/sdpj/gpack/lapackwrap/Dlasrt.java | 207 |
} while (d[pointer_d + i].isGreaterThan(dmnmx)); if (i < j) { RS tmp = d[pointer_d + i]; d[pointer_d + i] = d[pointer_d + j]; d[pointer_d + j] = tmp; } } while (i < j); if (j - start > endd - j - 1) { ++stkpnt; stack[(stkpnt) * 2 + 1 - 3 + pointer_stack] = start; stack[(stkpnt) * 2 + 2 - 3 + pointer_stack] = j; ++stkpnt; stack[(stkpnt) * 2 + 1 - 3 + pointer_stack] = j + 1; stack[(stkpnt) * 2 + 2 - 3 + pointer_stack] = endd; } else { ++stkpnt; stack[(stkpnt) * 2 + 1 - 3 + pointer_stack] = j + 1; stack[(stkpnt) * 2 + 2 - 3 + pointer_stack] = endd; ++stkpnt; stack[(stkpnt) * 2 + 1 - 3 + pointer_stack] = start; stack[(stkpnt) * 2 + 2 - 3 + pointer_stack] = j; } } else { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2629 |
org/mklab/sdpj/algebra/Algebra.java | 2785 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2763 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2919 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("plus:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans = a - b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> minus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 949 |
org/mklab/sdpj/algebra/Algebra.java | 1035 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1083 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1169 |
System.arraycopy(retMat_i, 0, ans.denseElements, ans.getRowSize() * i, retMat_i.length); } else { RS[] aMat_j = unit.createArray(a.denseElements.length - a.getRowSize() * j); RS[] retMat_j = unit.createArray(ans.denseElements.length - ans.getRowSize() * j); System.arraycopy(a.denseElements, a.getRowSize() * j, aMat_j, 0, aMat_j.length); System.arraycopy(ans.denseElements, ans.getRowSize() * j, retMat_j, 0, retMat_j.length); BLAS.daxpy(b.getColumnSize(), value, aMat_j, 1, retMat_j, 1); System.arraycopy(retMat_j, 0, ans.denseElements, ans.getRowSize() * j, retMat_j.length); } } return ans; case DENSE: if (ans.isDense() == false || a.isDense() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } BLAS.dgemm( "NoTranspose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), scalar, a.denseElements, a.getRowSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 299 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 368 |
for (int i = 0; i < a.getBlockSize(); ++i) { ans = ans.add(getInnerProduct(a.getBlock(i), b.getBlock(i))); } return ans; } /** * 内積の計算を行います。 Al.getInnerProduct(ret,aVec,bVec)をret=Al.getInnerProduct(aVec,bVec)に変更。 * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 内積 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS getInnerProduct(BlockSparseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("getInnerProduct:: different memory size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); RS ans = unit.create(0); |
File | Line |
---|---|
org/mklab/sdpj/gpack/blaswrap/Dtrsm.java | 278 |
org/mklab/sdpj/gpack/blaswrap/Dtrsm.java | 307 |
for (int k = 1; k <= j - 1; ++k) { int ap = j * a_dim1 + k + pointer_a; if (!a[ap].equals(unit.create(0), unit.getMachineEpsilon())) { for (int i = 1; i <= m; ++i) { // b_ref(i, j) = b_ref(i, j) - a_ref(k, j) * b_ref(i,k); int bp = j * b_dim1 + i + pointer_b; b[bp] = b[bp].subtract(a[ap].multiply(b[k * b_dim1 + i + pointer_b])); } } } if (nounit) { RS temp = unit.create(1).divide(a[j * a_dim1 + j + pointer_a]); for (int i = 1; i <= m; ++i) { // b_ref(i, j) = temp * b_ref(i, j); int p = j * b_dim1 + i + pointer_b; b[p] = temp.multiply(b[p]); } } } } else { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 291 |
org/mklab/sdpj/algebra/Algebra.java | 316 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS getInnerProduct(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("getInnerProduct:: different memory size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); RS ans = unit.create(0); for (int i = 0; i < a.getBlockSize(); ++i) { ans = ans.add(getInnerProduct(a.getBlock(i), b.getBlock(i))); } return ans; } /** * 内積の計算を行います。 Al.getInnerProduct(ret,aVec,bVec)をret=Al.getInnerProduct(aVec,bVec)に変更。 * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 内積 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS getInnerProduct(BlockSparseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dlarfb.java | 381 |
org/mklab/sdpj/gpack/lapackwrap/Dlarfb.java | 632 |
System.arraycopy(vTemp, 0, this.v, v_dim1 + m - k + 1 + pointer_v, vTemp.length); /* C2 := C2 - W' */ //配列を元に戻す。 this.arraycopyCTempOffsetForC(); this.arraycopyWorkTempOffsetForWork(); for (int j = 1; j <= k; ++j) { for (int i = 1; i <= n; ++i) { this.c[i * c_dim1 + m - k + j + pointer_c] = this.c[i * c_dim1 + m - k + j + pointer_c].subtract(this.work[j * work_dim1 + i + pointer_work]); /* L80: */ } /* L90: */ } } else if (BLAS.lsame(side, "R")) { //$NON-NLS-1$ /* Form C * H or C * H' where C = ( C1 C2 ) W := C * V = (C1*V1 + C2*V2) (stored in WORK) W := C2 */ for (int j = 1; j <= k; ++j) { RS[] cTemp = unit.createArray(m); RS[] workTemp = unit.createArray(m); System.arraycopy(this.c, (n - k + j) * c_dim1 + 1 + pointer_c, cTemp, 0, m); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3041 |
org/mklab/sdpj/algebra/Algebra.java | 3104 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3175 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3238 |
public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> let(SparseMatrix<RS,RM,CS,CM> a, final char operator, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { DenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b, scalar); return ans; case '-': final RS minus_scalar = scalar.unaryMinus(); ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b, scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> let(SparseMatrix<RS,RM,CS,CM> a, final char operator, DenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3248 |
org/mklab/sdpj/algebra/Algebra.java | 3311 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3382 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3445 |
public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockSparseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { BlockDenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b, scalar); return ans; case '-': final RS minus_scalar = scalar.unaryMinus(); ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b, scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockSparseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/benchmark/Sdplib.java | 338 |
org/mklab/sdpj/benchmark/Sdplib.java | 452 |
this.target = "0"; //$NON-NLS-1$ String replacement = "100"; //$NON-NLS-1$ for (Integer i = 0; i < 13; i++) { if (i == 0) { this.run(replacement); this.target = replacement; } if (i > 0 && i <= 4) { replacement = "124-" + i.toString(); //$NON-NLS-1$ this.run(replacement); this.target = replacement; } if (i > 4 && i <= 8) { replacement = "250-" + Integer.valueOf(i - 4).toString(); //$NON-NLS-1$ this.run(replacement); this.target = replacement; } if (i > 8 && i <= 12) { replacement = "500-" + Integer.valueOf(i - 8).toString(); //$NON-NLS-1$ this.run(replacement); this.target = replacement; } } } } /** * test solver SDPJ with using problems of infp * * @param name name of problem folder * @throws IOException 読み込めない場合 */ @SuppressWarnings("boxing") private void testInfp(String name) throws IOException { |
File | Line |
---|---|
org/mklab/sdpj/gpack/blaswrap/Dsyr2k.java | 144 |
org/mklab/sdpj/gpack/blaswrap/Dsyrk.java | 121 |
int c_dim1 = ldc; int c_offset = 1 + c_dim1 * 1; int pointer_c = -c_offset; int nrowa; if (BLAS.lsame(trans, "N")) { //$NON-NLS-1$ nrowa = n; } else { nrowa = k; } boolean upper = BLAS.lsame(uplo, "U"); //$NON-NLS-1$ int info = 0; if (!upper && !BLAS.lsame(uplo, "L")) { //$NON-NLS-1$ info = 1; } else if (!BLAS.lsame(trans, "N") && !BLAS.lsame(trans, "T") && !BLAS.lsame(trans, "C")) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ info = 2; } else if (n < 0) { info = 3; } else if (k < 0) { info = 4; } else if (lda < Math.max(1, nrowa)) { info = 7; } else if (ldb < Math.max(1, nrowa)) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 124 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 150 |
throw new RuntimeException("getInnerProduct:: different memory size"); //$NON-NLS-1$ } return BLAS.<RS,RM,CS,CM> ddot(size, a.getElements(), 1, b.getElements(), 1); } /** * 内積の計算を行います。 Al.getInnerProduct(ret,aVec,bVec)をret=Al.getInnerProduct(aVec,bVec)に変更。 * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param b b * @return 最小固有値 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS getInnerProduct(BlockVector<RS,RM,CS,CM> a, BlockVector<RS,RM,CS,CM> b) { // 内積=Al.getInnerProduct(vec1,vec2);に書き換えたほうがいいかもね! if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("getInnerProduct:: different memory size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); RS ret = unit.create(0); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2246 |
org/mklab/sdpj/algebra/Algebra.java | 2357 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2380 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2491 |
RS value = b.getSparseElement(index).multiply(scalar); if (i != j) { int ij = i + ans.getColumnSize() * j; int ji = j + ans.getColumnSize() * i; ans.denseElements[ij] = ans.denseElements[ij].add(value); ans.denseElements[ji] = ans.denseElements[ji].add(value); } else { int ii = i + ans.getColumnSize() * i; ans.denseElements[ii] = ans.denseElements[ii].add(value); } } int index; int counter; for (index = amari, counter = 0; counter < shou; ++counter, index += 4) { int i1 = b.rowIndex[index]; int j1 = b.columnIndex[index]; RS value1 = b.getSparseElement(index).multiply(scalar); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 748 |
org/mklab/sdpj/algebra/Algebra.java | 832 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 882 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 966 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply(SparseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getColumnSize() != b.getRowSize()) { throw new RuntimeException("multiply :: different matrix size"); //$NON-NLS-1$ } final RS unit = b.getElementUnit(); DenseMatrix<RS,RM,CS,CM> ans = new DenseMatrix<>(a.getRowSize(), b.getColumnSize(), b.getDenseOrDiagonal(), unit); switch (a.getSparseOrDenseOrDiagonal()) { case SPARSE: if (ans.isDense() == false || b.isDense() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } for (int index = 0; index < a.nonZeroCount; ++index) { int i = a.rowIndex[index]; int j = a.columnIndex[index]; RS value = a.getSparseElement(index).multiply(scalar); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 918 |
org/mklab/sdpj/algebra/Algebra.java | 1004 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1052 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1138 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply(DenseMatrix<RS,RM,CS,CM> a, SparseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getColumnSize() != b.getRowSize()) { throw new RuntimeException("multiply :: different matrix size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); DenseMatrix<RS,RM,CS,CM> ans = new DenseMatrix<>(a.getRowSize(), b.getColumnSize(), a.getDenseOrDiagonal(), unit); switch (b.getSparseOrDenseOrDiagonal()) { case SPARSE: if (ans.isDense() == false || a.isDense() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } for (int index = 0; index < b.nonZeroCount; ++index) { int i = b.rowIndex[index]; int j = b.columnIndex[index]; RS value = b.getSparseElement(index).multiply(scalar); |
File | Line |
---|---|
org/mklab/sdpj/algorithm/StepLength.java | 307 |
org/mklab/sdpj/algorithm/StepLength.java | 354 |
RS[][] matrixdA = newton.getDzMat().getArrayOfElements(); //NumericalMatrix<RS> A = new BaseNumericalMatrix<>(matrixA); RM A = matrixA[0][0].createGrid(matrixA); //NumericalMatrix<RS> dA = new BaseNumericalMatrix<>(matrixdA); RM dA = matrixdA[0][0].createGrid(matrixdA); double alpha = 0.1; for (int i = 1; i <= 10; i++) { alpha *= i; dA =dA.multiply(alpha); A =A.add(dA); RS minimumEigenValue; if (guarantee) { MPFloatRumpMethod verifier = new MPFloatRumpMethod((MPFloatMatrix)A.multiply(alpha)); Guarantor<MPFloatRumpMethod> guarantor = new Guarantor<>(verifier); guarantor.solveWithEffectiveDigits(26); MPFloatRumpMethod guranteedVerifier = guarantor.getGuranteedVerifier(); minimumEigenValue = (RS)guranteedVerifier.getEigenValue().getInfimum().getRealPart().min(); } else { CM eigenValue = A.eigenValue(); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3135 |
org/mklab/sdpj/algebra/Algebra.java | 3279 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3269 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3413 |
DenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b); return ans; case '-': ans = minus(a, b); //final RS unit = a.getElementUnit(); //final RS minus_scalar = unit.create(-1); //ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' 't' 'T' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockDenseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dlatrd.java | 328 |
org/mklab/sdpj/gpack/lapackwrap/Dlatrd.java | 447 |
private int dsymv(String uplo, int n, RS alpha, int aIndex, int lda, int xIndex, int incx, RS beta, int yIndex, int incy) { final RS unit = alpha.createUnit(); RS[] aTemp = unit.createArray(this.a.length - aIndex); RS[] x = unit.createArray(this.a.length - xIndex); RS[] y = unit.createArray(this.w.length - yIndex); System.arraycopy(this.a, aIndex, aTemp, 0, aTemp.length); System.arraycopy(this.a, xIndex, x, 0, x.length); System.arraycopy(this.w, yIndex, y, 0, y.length); |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 366 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 498 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 561 |
} } } else if (cname && LibF77.compare(c2, "UN", 2, 2) == 0) { //$NON-NLS-1$ if (c3[0] == 'G') { if (LibF77.compare(c4, "QR", 2, 2) == 0 || LibF77.compare(c4, "RQ", 2, 2) == 0 || LibF77.compare(c4, "LQ", 2, 2) == 0 || LibF77.compare(c4, "QL", 2, 2) == 0 || LibF77.compare(c4, "HR", 2, 2) == 0 || LibF77.compare(c4, "TR", 2, 2) == 0 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ || LibF77.compare(c4, "BR", 2, 2) == 0) { //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 355 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 487 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 555 |
} } else if (sname && LibF77.compare(c2, "OR", 2, 2) == 0) { //$NON-NLS-1$ if (c3[0] == 'G') { if (LibF77.compare(c4, "QR", 2, 2) == 0 || LibF77.compare(c4, "RQ", 2, 2) == 0 || LibF77.compare(c4, "LQ", 2, 2) == 0 || LibF77.compare(c4, "QL", 2, 2) == 0 || LibF77.compare(c4, "HR", 2, 2) == 0 || LibF77.compare(c4, "TR", 2, 2) == 0 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ || LibF77.compare(c4, "BR", 2, 2) == 0) { //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/algorithm/Newton.java | 345 |
org/mklab/sdpj/algorithm/Newton.java | 400 |
if (i != j) { this.bMat.denseElements[i + this.bMat.getColumnSize() * j] = this.bMat.denseElements[i + this.bMat.getColumnSize() * j].add(value); this.bMat.denseElements[j + this.bMat.getColumnSize() * i] = this.bMat.denseElements[j + this.bMat.getColumnSize() * i].add(value); } else { this.bMat.denseElements[i + this.bMat.getColumnSize() * i] = this.bMat.denseElements[i + this.bMat.getColumnSize() * i].add(value); } } } } else { |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dlasr.java | 255 |
org/mklab/sdpj/gpack/lapackwrap/Dlasr.java | 269 |
for (int j = 1; j <= n - 1; ++j) { RS ctemp = c[pointer_c + j]; RS stemp = s[pointer_s + j]; if (!ctemp.isUnit() || !stemp.isZero()) { for (int i = 1; i <= m; ++i) { int p1 = (j) * a_dim1 + i + pointer_a; int p2 = (j + 1) * a_dim1 + i + pointer_a; RS temp = a[p2]; a[p2] = (ctemp.multiply(temp)).subtract(stemp.multiply(a[p1])); a[p1] = (stemp.multiply(temp)).add(ctemp.multiply(a[p1])); } } } } else if (BLAS.lsame(direct, "B")) { //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 937 |
org/mklab/sdpj/algebra/Algebra.java | 1030 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1071 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1164 |
RS[] aMat_i = unit.createArray(a.denseElements.length - a.getRowSize() * i); System.arraycopy(a.denseElements, a.getRowSize() * i, aMat_i, 0, aMat_i.length); RS[] retMat_j = unit.createArray(ans.denseElements.length - ans.getRowSize() * j); System.arraycopy(ans.denseElements, ans.getRowSize() * j, retMat_j, 0, retMat_j.length); BLAS.daxpy(b.getColumnSize(), value, aMat_i, 1, retMat_j, 1); System.arraycopy(retMat_j, 0, ans.denseElements, ans.getRowSize() * j, retMat_j.length); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 944 |
org/mklab/sdpj/algebra/Algebra.java | 1023 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1078 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1157 |
RS[] aMat_j = unit.createArray(a.denseElements.length - a.getRowSize() * j); System.arraycopy(a.denseElements, a.getRowSize() * j, aMat_j, 0, aMat_j.length); RS[] retMat_i = unit.createArray(ans.denseElements.length - ans.getRowSize() * i); System.arraycopy(ans.denseElements, ans.getRowSize() * i, retMat_i, 0, retMat_i.length); BLAS.daxpy(b.getColumnSize(), value, aMat_j, 1, retMat_i, 1); System.arraycopy(retMat_i, 0, ans.denseElements, ans.getRowSize() * i, retMat_i.length); |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dlasr.java | 192 |
org/mklab/sdpj/gpack/lapackwrap/Dlasr.java | 206 |
for (int j = 2; j <= m; ++j) { RS ctemp = c[pointer_c + j - 1]; RS stemp = s[pointer_s + j - 1]; if (!ctemp.isUnit() || !stemp.isZero()) { for (int i = 1; i <= n; ++i) { int p1 = i * a_dim1 + 1 + pointer_a; int p2 = i * a_dim1 + j + pointer_a; RS temp = a[p2]; a[p2] = (ctemp.multiply(temp)).subtract(stemp.multiply(a[p1])); a[p1] = (stemp.multiply(temp)).add(ctemp.multiply(a[p1])); } } } } else if (BLAS.lsame(direct, "B")) { //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dlasr.java | 285 |
org/mklab/sdpj/gpack/lapackwrap/Dlasr.java | 299 |
for (int j = 2; j <= n; ++j) { RS ctemp = c[pointer_c + j - 1]; RS stemp = s[pointer_s + j - 1]; if (!ctemp.isUnit() || !stemp.isZero()) { for (int i = 1; i <= m; ++i) { int p1 = a_dim1 + i + pointer_a; int p2 = (j) * a_dim1 + i + pointer_a; RS temp = a[p2]; a[p2] = (ctemp.multiply(temp)).subtract(stemp.multiply(a[p1])); a[p1] = (stemp.multiply(temp)).add(ctemp.multiply(a[p1])); } } } } else if (BLAS.lsame(direct, "B")) { //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2263 |
org/mklab/sdpj/algebra/Algebra.java | 2374 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2397 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2508 |
RS value1 = b.getSparseElement(index).multiply(scalar); if (i1 != j1) { int ij = i1 + ans.getColumnSize() * j1; int ji = j1 + ans.getColumnSize() * i1; ans.denseElements[ij] = ans.denseElements[ij].add(value1); ans.denseElements[ji] = ans.denseElements[ji].add(value1); } else { int ii = i1 + ans.getColumnSize() * i1; ans.denseElements[ii] = ans.denseElements[ii].add(value1); } int i2 = b.rowIndex[index + 1]; int j2 = b.columnIndex[index + 1]; RS value2 = b.getSparseElement(index + 1).multiply(scalar); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2275 |
org/mklab/sdpj/algebra/Algebra.java | 2386 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2409 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2520 |
RS value2 = b.getSparseElement(index + 1).multiply(scalar); if (i2 != j2) { int ij = i2 + ans.getColumnSize() * j2; int ji = j2 + ans.getColumnSize() * i2; ans.denseElements[ij] = ans.denseElements[ij].add(value2); ans.denseElements[ji] = ans.denseElements[ji].add(value2); } else { int ii = i2 + ans.getColumnSize() * i2; ans.denseElements[ii] = ans.denseElements[ii].add(value2); } int i3 = b.rowIndex[index + 2]; int j3 = b.columnIndex[index + 2]; RS value3 = b.getSparseElement(index + 2).multiply(scalar); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2287 |
org/mklab/sdpj/algebra/Algebra.java | 2398 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2421 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2532 |
RS value3 = b.getSparseElement(index + 2).multiply(scalar); if (i3 != j3) { int ij = i3 + ans.getColumnSize() * j3; int ji = j3 + ans.getColumnSize() * i3; ans.denseElements[ij] = ans.denseElements[ij].add(value3); ans.denseElements[ji] = ans.denseElements[ji].add(value3); } else { int ii = i3 + ans.getColumnSize() * i3; ans.denseElements[ii] = ans.denseElements[ii].add(value3); } int i4 = b.rowIndex[index + 3]; int j4 = b.columnIndex[index + 3]; RS value4 = b.getSparseElement(index + 3).multiply(scalar); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1907 |
org/mklab/sdpj/algebra/Algebra.java | 2019 |
org/mklab/sdpj/algebra/Algebra.java | 2357 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2041 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2153 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2491 |
RS value = a.getSparseElement(index); if (i != j) { int ij = i + ans.getColumnSize() * j; int ji = j + ans.getColumnSize() * i; ans.denseElements[ij] = ans.denseElements[ij].add(value); ans.denseElements[ji] = ans.denseElements[ji].add(value); } else { int ii = i + ans.getColumnSize() * i; ans.denseElements[ii] = ans.denseElements[ii].add(value); } } int index; int counter; for (index = amari, counter = 0; counter < shou; ++counter, index += 4) { int i1 = a.rowIndex[index]; |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2131 |
org/mklab/sdpj/algebra/Algebra.java | 2459 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2265 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2593 |
RS value = a.getSparseElement(index); if (i != j) { int ij = i + ans.getColumnSize() * j; int ji = j + ans.getColumnSize() * i; ans.denseElements[ij] = ans.denseElements[ij].subtract(value); ans.denseElements[ji] = ans.denseElements[ji].subtract(value); } else { int ii = i + ans.getColumnSize() * i; ans.denseElements[ii] = ans.denseElements[ii].subtract(value); } } int index; int counter; for (index = amari, counter = 0; counter < shou; ++counter, index += 4) { int i1 = a.rowIndex[index]; |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3042 |
org/mklab/sdpj/algebra/Algebra.java | 3105 |
org/mklab/sdpj/algebra/Algebra.java | 3249 |
org/mklab/sdpj/algebra/Algebra.java | 3312 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3176 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3239 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3383 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3446 |
DenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b, scalar); return ans; case '-': final RS minus_scalar = scalar.unaryMinus(); ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b, scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> let(SparseMatrix<RS,RM,CS,CM> a, final char operator, DenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dlasr.java | 222 |
org/mklab/sdpj/gpack/lapackwrap/Dlasr.java | 236 |
for (int j = 1; j <= m - 1; ++j) { RS ctemp = c[pointer_c + j]; RS stemp = s[pointer_s + j]; if (!ctemp.isUnit() || !stemp.isZero()) { for (int i = 1; i <= n; ++i) { int p1 = i * a_dim1 + m + pointer_a; int p2 = i * a_dim1 + j + pointer_a; RS temp = a[p2]; a[p2] = (stemp.multiply(a[p1])).add(ctemp.multiply(temp)); a[p1] = (ctemp.multiply(a[p1])).subtract(stemp.multiply(temp)); } } } } else if (BLAS.lsame(direct, "B")) { //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 556 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 563 |
} else if (sname && LibF77.compare(c2, "OR", 2, 2) == 0) { //$NON-NLS-1$ if (c3[0] == 'G') { if (LibF77.compare(c4, "QR", 2, 2) == 0 || LibF77.compare(c4, "RQ", 2, 2) == 0 || LibF77.compare(c4, "LQ", 2, 2) == 0 || LibF77.compare(c4, "QL", 2, 2) == 0 || LibF77.compare(c4, "HR", 2, 2) == 0 || LibF77.compare(c4, "TR", 2, 2) == 0 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ || LibF77.compare(c4, "BR", 2, 2) == 0) { //$NON-NLS-1$ nx = 128; } } } else if (cname && LibF77.compare(c2, "UN", 2, 2) == 0) { //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2342 |
org/mklab/sdpj/algebra/Algebra.java | 2447 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2476 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2581 |
throw new RuntimeException("plus :: different matrix size"); //$NON-NLS-1$ } // ans = a DenseMatrix<RS,RM,CS,CM> ans = a.createClone(); // ans += (*scalar) * b switch (b.getSparseOrDenseOrDiagonal()) { case SPARSE: int shou = b.nonZeroCount / 4; int amari = b.nonZeroCount % 4; for (int index = 0; index < amari; ++index) { int i = b.rowIndex[index]; int j = b.columnIndex[index]; RS value = b.getSparseElement(index); if (i != j) { int ij = i + ans.getColumnSize() * j; int ji = j + ans.getColumnSize() * i; ans.denseElements[ij] = ans.denseElements[ij].add(value); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3071 |
org/mklab/sdpj/algebra/Algebra.java | 3134 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3205 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3268 |
public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> let(SparseMatrix<RS,RM,CS,CM> a, final char operator, DenseMatrix<RS,RM,CS,CM> b) { DenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b); return ans; case '-': ans = minus(a, b); //final RS unit = a.getElementUnit(); //final RS minus_scalar = unit.create(-1); //ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> let(DenseMatrix<RS,RM,CS,CM> a, final char operator, SparseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3278 |
org/mklab/sdpj/algebra/Algebra.java | 3342 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3412 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3476 |
public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockSparseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b) { BlockDenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b); return ans; case '-': ans = minus(a, b); //final RS unit = a.getElementUnit(); //final RS minus_scalar = unit.create(-1); //ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockDenseMatrix<RS,RM,CS,CM> a, final char operator, BlockSparseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/main/SdpjParameters.java | 155 |
org/mklab/sdpj/main/SdpjParameters.java | 197 |
if (target.equals("-pt") && i + 1 < argc) { //$NON-NLS-1$ int tmp = atoi(arguments[i + 1]); switch (tmp) { case 0: this.parameterType = ParameterType.PARAMETER_DEFAULT; break; case 1: this.parameterType = ParameterType.PARAMETER_AGGRESSIVE; break; case 2: this.parameterType = ParameterType.PARAMETER_STABLE; break; case 3: this.parameterType = ParameterType.PARAMETER_MP115_DEFAULT; break; case 4: this.parameterType = ParameterType.PARAMETER_MP115_STABLE; break; default: this.parameterType = ParameterType.PARAMETER_DEFAULT; } if (tmp == 3 || tmp == 4) { this.dataType = "mpfloat"; //$NON-NLS-1$ } else { this.dataType = "double"; //$NON-NLS-1$ } i++; this.paraFile = null; this.isParameter = false; |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1306 |
org/mklab/sdpj/algebra/Algebra.java | 1355 |
org/mklab/sdpj/algebra/Algebra.java | 1404 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1440 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1489 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1538 |
BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2608 |
org/mklab/sdpj/algebra/Algebra.java | 2685 |
org/mklab/sdpj/algebra/Algebra.java | 2764 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2742 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2819 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2898 |
BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * ans = a + b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/blaswrap/Dtrmm.java | 290 |
org/mklab/sdpj/gpack/blaswrap/Dtrmm.java | 312 |
for (int j = 1; j <= k - 1; ++j) { if (!a[k * a_dim1 + j + pointer_a].isZero()) { RS temp = alpha.multiply(a[k * a_dim1 + j + pointer_a]); for (int i = 1; i <= m; ++i) { int p = j * b_dim1 + i + pointer_b; b[p] = b[p].add(temp.multiply(b[k * b_dim1 + i + pointer_b])); } } } RS temp = alpha; if (nounit) { temp = temp.multiply(a[k * a_dim1 + k + pointer_a]); } if (!temp.equals(unit.create(1))) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1907 |
org/mklab/sdpj/algebra/Algebra.java | 2019 |
org/mklab/sdpj/algebra/Algebra.java | 2246 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2041 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2153 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2380 |
RS value = a.getSparseElement(index); if (i != j) { int ij = i + ans.getColumnSize() * j; int ji = j + ans.getColumnSize() * i; ans.denseElements[ij] = ans.denseElements[ij].add(value); ans.denseElements[ji] = ans.denseElements[ji].add(value); } else { int ii = i + ans.getColumnSize() * i; ans.denseElements[ii] = ans.denseElements[ii].add(value); } } int index; int counter; for (index = amari, counter = 0; counter < shou; ++counter, index += 4) { int i1 = a.rowIndex[index]; |
File | Line |
---|---|
org/mklab/sdpj/gpack/blaswrap/Dsyr2.java | 154 |
org/mklab/sdpj/gpack/blaswrap/Dsyr2.java | 185 |
for (int i = 1; i <= j; ++i) { int p = j * a_dim1 + i + pointer_a; a[p] = a[p].add(x[i - 1].multiply(temp1)).add(y[i - 1].multiply(temp2)); } } } } else { for (int j = 1; j <= n; ++j) { if (!x[jx - 1].isZero() || !y[jy - 1].isZero()) { RS temp1 = alpha.multiply(y[jy - 1]); RS temp2 = alpha.multiply(x[jx - 1]); int ix = kx; |
File | Line |
---|---|
org/mklab/sdpj/gpack/blaswrap/Dsyr2k.java | 240 |
org/mklab/sdpj/gpack/blaswrap/Dsyrk.java | 209 |
c[ci] = c[ci].add(a[ai].multiply(temp1)).add(b[bi].multiply(temp2)); } } } } } else { for (int j = 1; j <= n; ++j) { if (beta.isZero()) { for (int i = j; i <= n; ++i) { c[j * c_dim1 + i + pointer_c] = unit.createZero(); } } else if (!beta.equals(unit.createUnit())) { for (int i = j; i <= n; ++i) { int p = j * c_dim1 + i + pointer_c; c[p] = beta.multiply(c[p]); } } for (int l = 1; l <= k; ++l) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dorgtr.java | 600 |
org/mklab/sdpj/gpack/lapackwrap/Dorgtr.java | 619 |
if (BLAS.lsame(side, "L")) { //$NON-NLS-1$ /* Form H * C */ if (!tau.isZero()) { //array copy RS[] cTemp = unit.createArray(c.length - (c_offset + pointer_c)); RS[] workTemp = unit.createArray(this.work.length - (1 + pointer_work)); RS[] vTemp = unit.createArray(v.length - (1 + pointer_v)); System.arraycopy(c, c_offset + pointer_c, cTemp, 0, cTemp.length); System.arraycopy(this.work, 1 + pointer_work, workTemp, 0, workTemp.length); System.arraycopy(v, 1 + pointer_v, vTemp, 0, vTemp.length); /* w := C' * v */ BLAS.dgemv("Transpose", m, n, c_b4, cTemp, ldc, vTemp, incv, c_b5, workTemp, 1); //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2634 |
org/mklab/sdpj/algebra/Algebra.java | 2711 |
org/mklab/sdpj/algebra/Algebra.java | 2790 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2768 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2845 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2924 |
BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans = a - b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> minus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2659 |
org/mklab/sdpj/algebra/Algebra.java | 2737 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2793 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2871 |
BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = minus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans = a + b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockSparseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dlarfb.java | 281 |
org/mklab/sdpj/gpack/lapackwrap/Dlarfb.java | 296 |
BLAS.dtrmm("Right", "Lower", "No transpose", "Unit", m, k, c_b14, this.vTempOffset, ldv, this.workTempOffset, ldwork); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ if (n > k) { /* W := W + C2 * V2 */ RS[] vTemp = unit.createArray(this.v.length - (v_dim1 + k + 1 + pointer_v)); RS[] cTemp = unit.createArray(this.c.length - ((k + 1) * c_dim1 + 1 + pointer_c)); System.arraycopy(this.v, v_dim1 + k + 1 + pointer_v, this.v, 0, vTemp.length); System.arraycopy(this.c, (k + 1) * c_dim1 + 1 + pointer_c, cTemp, 0, cTemp.length); BLAS.dgemm("No transpose", "No transpose", m, k, n - k, c_b14, cTemp, ldc, vTemp, ldv, c_b14, this.workTempOffset, ldwork); //$NON-NLS-1$ //$NON-NLS-2$ |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 356 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 500 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 563 |
} else if (sname && LibF77.compare(c2, "OR", 2, 2) == 0) { //$NON-NLS-1$ if (c3[0] == 'G') { if (LibF77.compare(c4, "QR", 2, 2) == 0 || LibF77.compare(c4, "RQ", 2, 2) == 0 || LibF77.compare(c4, "LQ", 2, 2) == 0 || LibF77.compare(c4, "QL", 2, 2) == 0 || LibF77.compare(c4, "HR", 2, 2) == 0 || LibF77.compare(c4, "TR", 2, 2) == 0 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ || LibF77.compare(c4, "BR", 2, 2) == 0) { //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 368 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 488 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 556 |
} else if (cname && LibF77.compare(c2, "UN", 2, 2) == 0) { //$NON-NLS-1$ if (c3[0] == 'G') { if (LibF77.compare(c4, "QR", 2, 2) == 0 || LibF77.compare(c4, "RQ", 2, 2) == 0 || LibF77.compare(c4, "LQ", 2, 2) == 0 || LibF77.compare(c4, "QL", 2, 2) == 0 || LibF77.compare(c4, "HR", 2, 2) == 0 || LibF77.compare(c4, "TR", 2, 2) == 0 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ || LibF77.compare(c4, "BR", 2, 2) == 0) { //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2654 |
org/mklab/sdpj/algebra/Algebra.java | 2811 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2788 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2945 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> minus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("minus:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = minus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1330 |
org/mklab/sdpj/algebra/Algebra.java | 1379 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1464 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1513 |
BlockDenseMatrix<RS,RM,CS,CM> ans = a.createClone(); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockSparseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/blaswrap/Dsyrk.java | 241 |
org/mklab/sdpj/gpack/blaswrap/Dsyrk.java | 257 |
for (int i = 1; i <= j; ++i) { RS temp = unit.createZero(); for (int l = 1; l <= k; ++l) { int p = i * a_dim1 + l + pointer_a; temp = temp.add(a[p].multiply(a[j * a_dim1 + l + pointer_a])); } int p = j * c_dim1 + i + pointer_c; if (beta.isZero()) { c[p] = alpha.multiply(temp); } else { c[p] = (alpha.multiply(temp)).add(beta.multiply(c[p])); } } } } else { |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dlae2.java | 17 |
org/mklab/sdpj/gpack/lapackwrap/Dlaev2.java | 17 |
public class Dlae2<RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> { /** * -- LAPACK auxiliary routine (version 3.0) -- Univ. of Tennessee, Univ. of * California Berkeley, NAG Ltd., Courant Institute, Argonne National Lab, and * Rice University October 31, 1992 * <p> * <p> * Purpose ======= DLAE2 computes the eigenvalues of a 2-by-2 symmetric matrix * [ A B ] [ B C ]. On return, RT1 is the eigenvalue of larger absolute value, * and RT2 is the eigenvalue of smaller absolute value. Arguments ========= A * (input) DOUBLE PRECISION The (1,1) element of the 2-by-2 matrix. B (input) * DOUBLE PRECISION The (1,2) and (2,1) elements of the 2-by-2 matrix. C * (input) DOUBLE PRECISION The (2,2) element of the 2-by-2 matrix. RT1 * (output) DOUBLE PRECISION The eigenvalue of larger absolute value. RT2 * (output) DOUBLE PRECISION The eigenvalue of smaller absolute value. Further * Details =============== RT1 is accurate to a few ulps barring * over/underflow. RT2 may be inaccurate if there is massive cancellation in * the determinant A*C-B*B; higher precision or correctly rounded or correctly * truncated arithmetic would be needed to compute RT2 accurately in all * cases. Overflow is possible only if RT1 is within a factor of 5 of * overflow. Underflow is harmless if the input data is 0 or exceeds * underflow_threshold / macheps. * ===================================================================== */ /** * @param a a * @param b b * @param c c * @return {rt1, rt2} */ RS[] execute(RS a, RS b, RS c) { final RS unit = a.createUnit(); RS sm = a.add(c); RS df = a.subtract(c); RS adf = df.abs(); RS tb = b.add(b); RS ab = tb.abs(); RS acmn; |
File | Line |
---|---|
org/mklab/sdpj/iocenter/SolverIO.java | 346 |
org/mklab/sdpj/iocenter/SolverIO.java | 351 |
this.Display.printf("%2d %s %s %s %s %s %s %s %s\n", this.pIteration, this.mu.getValue().toString("%4.2e"), this.theta.getDual().toString("%4.2e"), this.theta.getPrimal().toString("%4.2e"), //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$//$NON-NLS-4$ this.solveInfo.getObjValDual().unaryMinus().toString("%+7.2e"), //$NON-NLS-1$ this.solveInfo.getObjValPrimal().unaryMinus().toString("%+7.2e"), this.alpha.getDual().toString("%4.2e"), this.alpha.getPrimal().toString("%4.2e"), this.beta.getValue().toString("%4.2e")); //$NON-NLS-1$ //$NON-NLS-2$//$NON-NLS-3$//$NON-NLS-4$ } |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 361 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 373 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 493 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 505 |
} } else if (c3[0] == 'M') { if (LibF77.compare(c4, "QR", 2, 2) == 0 || LibF77.compare(c4, "RQ", 2, 2) == 0 || LibF77.compare(c4, "LQ", 2, 2) == 0 || LibF77.compare(c4, "QL", 2, 2) == 0 || LibF77.compare(c4, "HR", 2, 2) == 0 || LibF77.compare(c4, "TR", 2, 2) == 0 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ || LibF77.compare(c4, "BR", 2, 2) == 0) { //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1450 |
org/mklab/sdpj/algebra/Algebra.java | 1496 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1584 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1630 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> tran_multiply(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getRowSize() != b.getRowSize() || a.getDenseOrDiagonal() != b.getDenseOrDiagonal()) { Tools.error("multiply :: different matrix size"); //$NON-NLS-1$ } final RS unit = a.getElementUnit(); DenseMatrix<RS,RM,CS,CM> ans = new DenseMatrix<>(a.getColumnSize(), b.getColumnSize(), a.getDenseOrDiagonal(), unit); switch (ans.getDenseOrDiagonal()) { case DENSE: BLAS.dgemm( "Transpose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), scalar, a.denseElements, a.getColumnSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ |
File | Line |
---|---|
org/mklab/sdpj/gpack/blaswrap/Dsyr2k.java | 277 |
org/mklab/sdpj/gpack/blaswrap/Dsyr2k.java | 294 |
for (int i = 1; i <= j; ++i) { RS temp1 = unit.createZero(); RS temp2 = unit.createZero(); for (int l = 1; l <= k; ++l) { temp1 = temp1.add(a[i * a_dim1 + l + pointer_a].multiply(b[j * b_dim1 + l + pointer_b])); temp2 = temp2.add(b[i * b_dim1 + l + pointer_b].multiply(a[j * a_dim1 + l + pointer_a])); } int p = j * c_dim1 + i + pointer_c; if (beta.isZero()) { c[p] = (alpha.multiply(temp1)).add(alpha.multiply(temp2)); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3072 |
org/mklab/sdpj/algebra/Algebra.java | 3135 |
org/mklab/sdpj/algebra/Algebra.java | 3279 |
org/mklab/sdpj/algebra/Algebra.java | 3343 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3206 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3269 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3413 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3477 |
DenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b); return ans; case '-': ans = minus(a, b); //final RS unit = a.getElementUnit(); //final RS minus_scalar = unit.create(-1); //ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> let(DenseMatrix<RS,RM,CS,CM> a, final char operator, SparseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1284 |
org/mklab/sdpj/algebra/Algebra.java | 1382 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1418 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1516 |
Vector<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1960 |
org/mklab/sdpj/algebra/Algebra.java | 2299 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2094 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2433 |
RS value4 = a.getSparseElement(index + 3); if (i4 != j4) { int ij = i4 + ans.getColumnSize() * j4; int ji = j4 + ans.getColumnSize() * i4; ans.denseElements[ij] = ans.denseElements[ij].add(value4); ans.denseElements[ji] = ans.denseElements[ji].add(value4); } else { int ii = i4 + ans.getColumnSize() * i4; ans.denseElements[ii] = ans.denseElements[ii].add(value4); } } return ans; case DENSE: if (ans.isDense() == false || b.isDense() == false) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1379 |
org/mklab/sdpj/algebra/Algebra.java | 1428 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1513 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1562 |
BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(b.getBlockSize(), b.getBlockStructs(), b.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockSparseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/datastructure/BlockDenseMatrix.java | 124 |
org/mklab/sdpj/datastructure/BlockDenseMatrix.java | 450 |
int columnNumber = matrix.getColumnSize(); switch (matrix.getDenseOrDiagonal()) { case DENSE: for (int i = 0; i < rowNumber; ++i) { for (int j = 0; j < columnNumber; ++j) { data[i + shift][j + shift] = matrix.denseElements[i + columnNumber * j]; } } break; case DIAGONAL: for (int j = 0; j < columnNumber; ++j) { data[j + shift][j + shift] = matrix.diagonalElements[j]; } break; default: throw new UnsupportedOperationException(); } } |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1301 |
org/mklab/sdpj/algebra/Algebra.java | 1540 |
org/mklab/sdpj/algebra/Algebra.java | 1682 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1435 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1674 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1816 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i), scalar); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3402 |
org/mklab/sdpj/algebra/Algebra.java | 3424 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3536 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3558 |
public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(Vector<RS,RM,CS,CM> a, final char operator, Vector<RS,RM,CS,CM> b) { switch (operator) { case '.': RS ans = getInnerProduct(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = inner_product(a,b) // op = '.' * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(DenseMatrix<RS,RM,CS,CM> a, final char operator, DenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3424 |
org/mklab/sdpj/algebra/Algebra.java | 3468 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3558 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3602 |
public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(DenseMatrix<RS,RM,CS,CM> a, final char operator, DenseMatrix<RS,RM,CS,CM> b) { switch (operator) { case '.': RS ans = getInnerProduct(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = inner_product(a,b) // op = '.' * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(DenseMatrix<RS,RM,CS,CM> a, final char operator, SparseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3490 |
org/mklab/sdpj/algebra/Algebra.java | 3534 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3624 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3668 |
public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(BlockVector<RS,RM,CS,CM> a, final char operator, BlockVector<RS,RM,CS,CM> b) { switch (operator) { case '.': RS ans = getInnerProduct(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = inner_product(a,b) // op = '.' * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(BlockDenseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3512 |
org/mklab/sdpj/algebra/Algebra.java | 3534 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3646 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3668 |
public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(BlockDenseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b) { switch (operator) { case '.': RS ans = getInnerProduct(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = inner_product(a,b) // op = '.' * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS run(BlockSparseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/blaswrap/Dsyr2k.java | 225 |
org/mklab/sdpj/gpack/blaswrap/Dsyr2k.java | 252 |
for (int i = 1; i <= j; ++i) { int p = j * c_dim1 + i + pointer_c; c[p] = beta.multiply(c[p]); } } for (int l = 1; l <= k; ++l) { int aj = l * a_dim1 + j + pointer_a; int bj = l * b_dim1 + j + pointer_b; if (!a[aj].isZero() || !b[bj].isZero()) { RS temp1 = alpha.multiply(b[bj]); RS temp2 = alpha.multiply(a[aj]); for (int i = 1; i <= j; ++i) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 357 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 362 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 369 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 374 |
if (c3[0] == 'G') { if (LibF77.compare(c4, "QR", 2, 2) == 0 || LibF77.compare(c4, "RQ", 2, 2) == 0 || LibF77.compare(c4, "LQ", 2, 2) == 0 || LibF77.compare(c4, "QL", 2, 2) == 0 || LibF77.compare(c4, "HR", 2, 2) == 0 || LibF77.compare(c4, "TR", 2, 2) == 0 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ || LibF77.compare(c4, "BR", 2, 2) == 0) { //$NON-NLS-1$ nb = 32; } } else if (c3[0] == 'M') { |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 489 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 494 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 501 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 506 |
if (c3[0] == 'G') { if (LibF77.compare(c4, "QR", 2, 2) == 0 || LibF77.compare(c4, "RQ", 2, 2) == 0 || LibF77.compare(c4, "LQ", 2, 2) == 0 || LibF77.compare(c4, "QL", 2, 2) == 0 || LibF77.compare(c4, "HR", 2, 2) == 0 || LibF77.compare(c4, "TR", 2, 2) == 0 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ || LibF77.compare(c4, "BR", 2, 2) == 0) { //$NON-NLS-1$ nbmin = 2; } } else if (c3[0] == 'M') { |
File | Line |
---|---|
org/mklab/sdpj/problem/ProblemCreater.java | 235 |
org/mklab/sdpj/problem/ProblemCreaterOnMemory.java | 172 |
if (i <= j && !tmp.isZero()) { SparseMatrix<RS,RM,CS,CM> target = this.C.getBlock(k); int count = target.nonZeroCount; target.rowIndex[count] = i; target.columnIndex[count] = j; // C must be opposite sign. target.sparseElements[count] = tmp.unaryMinus(); target.nonZeroCount++; if (i == j) { target.nonZeroEffect++; } else { target.nonZeroEffect += 2; } } } } } else { for (int j = 0; j < -size; ++j) { RS tmp = this.unit.valueOf(F[0][counter]); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1801 |
org/mklab/sdpj/algebra/Algebra.java | 2322 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1935 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2456 |
BLAS.daxpy(ans.getColumnSize(), scalar, b.diagonalElements, 1, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * ans = a + b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> plus(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1960 |
org/mklab/sdpj/algebra/Algebra.java | 2072 |
org/mklab/sdpj/algebra/Algebra.java | 2410 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2094 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2206 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2544 |
RS value4 = a.getSparseElement(index + 3); if (i4 != j4) { int ij = i4 + ans.getColumnSize() * j4; int ji = j4 + ans.getColumnSize() * i4; ans.denseElements[ij] = ans.denseElements[ij].add(value4); ans.denseElements[ji] = ans.denseElements[ji].add(value4); } else { int ii = i4 + ans.getColumnSize() * i4; ans.denseElements[ii] = ans.denseElements[ii].add(value4); } } return ans; case DENSE: |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1980 |
org/mklab/sdpj/algebra/Algebra.java | 2092 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2114 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2226 |
if (ans.isDiagonal() == false || b.isDiagonal() == false) { throw new RuntimeException("plus :: different matrix type"); //$NON-NLS-1$ } BLAS.dxpy(ans.getColumnSize(), a.diagonalElements, 1, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * ans = a + b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> plus(SparseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2184 |
org/mklab/sdpj/algebra/Algebra.java | 2512 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2318 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2646 |
RS value4 = a.getSparseElement(index + 3); if (i4 != j4) { int ij = i4 + ans.getColumnSize() * j4; int ji = j4 + ans.getColumnSize() * i4; ans.denseElements[ij] = ans.denseElements[ij].subtract(value4); ans.denseElements[ji] = ans.denseElements[ji].subtract(value4); } else { int ii = i4 + ans.getColumnSize() * i4; ans.denseElements[ii] = ans.denseElements[ii].subtract(value4); } } return ans; case DENSE: |
File | Line |
---|---|
org/mklab/sdpj/problem/ProblemCreater.java | 270 |
org/mklab/sdpj/problem/ProblemCreaterOnMemory.java | 206 |
if (i <= j && !tmp.isZero()) { SparseMatrix<RS,RM,CS,CM> target = this.A[k].getBlock(p); int count = target.nonZeroCount; target.rowIndex[count] = i; target.columnIndex[count] = j; target.sparseElements[count] = tmp; target.nonZeroCount++; if (i == j) { target.nonZeroEffect++; } else { target.nonZeroEffect += 2; } } } } } else { for (int j = 0; j < -size; ++j) { RS tmp = this.unit.valueOf(F[k + 1][counter]); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1330 |
org/mklab/sdpj/algebra/Algebra.java | 1428 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1464 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1562 |
BlockDenseMatrix<RS,RM,CS,CM> ans = a.createClone(); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockSparseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/blaswrap/Dcopy.java | 27 |
org/mklab/sdpj/gpack/blaswrap/Dcopy.java | 57 |
void dcopy(int size, double[] x, int incx, double[] y, int incy) { if (incx == 1 && incy == 1) { System.arraycopy(x, 0, y, 0, size); return; } int ix = 0; int iy = 0; if (incx < 0) { ix = (-(size) + 1) * incx; } if (incy < 0) { iy = (-(size) + 1) * incy; } for (int i = 1; i <= size; ++i) { y[iy] = x[ix]; ix += incx; iy += incy; } } |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1834 |
org/mklab/sdpj/algebra/Algebra.java | 2427 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1968 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2561 |
BLAS.dxpy(ans.getColumnSize(), b.diagonalElements, 1, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * ans = a - b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> minus(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1867 |
org/mklab/sdpj/algebra/Algebra.java | 1983 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2001 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2117 |
BLAS.dxmy(ans.getColumnSize(), b.diagonalElements, 1, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * ans = a + b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> plus(SparseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2207 |
org/mklab/sdpj/algebra/Algebra.java | 2322 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2341 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2456 |
BLAS.dxmy(ans.getColumnSize(), a.diagonalElements, 1, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * ans = a + b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> plus(DenseMatrix<RS,RM,CS,CM> a, SparseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/datastructure/DenseMatrix.java | 141 |
org/mklab/sdpj/datastructure/SparseMatrix.java | 136 |
buff.append("{"); //$NON-NLS-1$ for (int i = 0; i < this.rowSize - 1; ++i) { if (i == 0) { buff.append(" "); //$NON-NLS-1$ } else { buff.append(" "); //$NON-NLS-1$ } buff.append("{"); //$NON-NLS-1$ for (int j = 0; j < this.columnSize - 1; ++j) { buff.append(this.denseElements[i + this.columnSize * j] + ","); //$NON-NLS-1$ } buff.append(this.denseElements[i + this.columnSize * (getColumnSize() - 1)] + " },\n"); //$NON-NLS-1$ } if (getRowSize() > 1) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1936 |
org/mklab/sdpj/algebra/Algebra.java | 2048 |
org/mklab/sdpj/algebra/Algebra.java | 2386 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2070 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2182 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2520 |
RS value2 = a.getSparseElement(index + 1); if (i2 != j2) { int ij = i2 + ans.getColumnSize() * j2; int ji = j2 + ans.getColumnSize() * i2; ans.denseElements[ij] = ans.denseElements[ij].add(value2); ans.denseElements[ji] = ans.denseElements[ji].add(value2); } else { int ii = i2 + ans.getColumnSize() * i2; ans.denseElements[ii] = ans.denseElements[ii].add(value2); } int i3 = a.rowIndex[index + 2]; |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1948 |
org/mklab/sdpj/algebra/Algebra.java | 2060 |
org/mklab/sdpj/algebra/Algebra.java | 2398 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2082 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2194 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2532 |
RS value3 = a.getSparseElement(index + 2); if (i3 != j3) { int ij = i3 + ans.getColumnSize() * j3; int ji = j3 + ans.getColumnSize() * i3; ans.denseElements[ij] = ans.denseElements[ij].add(value3); ans.denseElements[ji] = ans.denseElements[ji].add(value3); } else { int ii = i3 + ans.getColumnSize() * i3; ans.denseElements[ii] = ans.denseElements[ii].add(value3); } int i4 = a.rowIndex[index + 3]; |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2160 |
org/mklab/sdpj/algebra/Algebra.java | 2488 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2294 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2622 |
RS value2 = a.getSparseElement(index + 1); if (i2 != j2) { int ij = i2 + ans.getColumnSize() * j2; int ji = j2 + ans.getColumnSize() * i2; ans.denseElements[ij] = ans.denseElements[ij].subtract(value2); ans.denseElements[ji] = ans.denseElements[ji].subtract(value2); } else { int ii = i2 + ans.getColumnSize() * i2; ans.denseElements[ii] = ans.denseElements[ii].subtract(value2); } int i3 = a.rowIndex[index + 2]; |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2172 |
org/mklab/sdpj/algebra/Algebra.java | 2500 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2306 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2634 |
RS value3 = a.getSparseElement(index + 2); if (i3 != j3) { int ij = i3 + ans.getColumnSize() * j3; int ji = j3 + ans.getColumnSize() * i3; ans.denseElements[ij] = ans.denseElements[ij].subtract(value3); ans.denseElements[ji] = ans.denseElements[ji].subtract(value3); } else { int ii = i3 + ans.getColumnSize() * i3; ans.denseElements[ii] = ans.denseElements[ii].subtract(value3); } int i4 = a.rowIndex[index + 3]; |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2072 |
org/mklab/sdpj/algebra/Algebra.java | 2299 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2206 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2433 |
RS value4 = a.getSparseElement(index + 3); if (i4 != j4) { int ij = i4 + ans.getColumnSize() * j4; int ji = j4 + ans.getColumnSize() * i4; ans.denseElements[ij] = ans.denseElements[ij].add(value4); ans.denseElements[ji] = ans.denseElements[ji].add(value4); } else { int ii = i4 + ans.getColumnSize() * i4; ans.denseElements[ii] = ans.denseElements[ii].add(value4); } } return ans; case DENSE: if (b.isDense() == false) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 357 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 369 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 494 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 506 |
if (c3[0] == 'G') { if (LibF77.compare(c4, "QR", 2, 2) == 0 || LibF77.compare(c4, "RQ", 2, 2) == 0 || LibF77.compare(c4, "LQ", 2, 2) == 0 || LibF77.compare(c4, "QL", 2, 2) == 0 || LibF77.compare(c4, "HR", 2, 2) == 0 || LibF77.compare(c4, "TR", 2, 2) == 0 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ || LibF77.compare(c4, "BR", 2, 2) == 0) { //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 362 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 374 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 489 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 501 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 557 |
org/mklab/sdpj/gpack/lapackwrap/Ilaenv.java | 564 |
} else if (c3[0] == 'M') { if (LibF77.compare(c4, "QR", 2, 2) == 0 || LibF77.compare(c4, "RQ", 2, 2) == 0 || LibF77.compare(c4, "LQ", 2, 2) == 0 || LibF77.compare(c4, "QL", 2, 2) == 0 || LibF77.compare(c4, "HR", 2, 2) == 0 || LibF77.compare(c4, "TR", 2, 2) == 0 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ || LibF77.compare(c4, "BR", 2, 2) == 0) { //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 174 |
org/mklab/sdpj/algebra/Algebra.java | 272 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 217 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 315 |
return BLAS.<RS,RM,CS,CM> ddot(length, a.denseElements, 1, b.denseElements, 1); case DIAGONAL: return BLAS.ddot(a.getColumnSize(), a.diagonalElements, 1, b.diagonalElements, 1); default: throw new IllegalArgumentException(); } } /** * 内積の計算を行います。 Al.getInnerProduct(ret,aVec,bVec)をret=Al.getInnerProduct(aVec,bVec)に変更。 * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 内積 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS getInnerProduct(SparseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 794 |
org/mklab/sdpj/algebra/Algebra.java | 879 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 928 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1013 |
"NoTranspose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), scalar, a.denseElements, a.getRowSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: if (ans.isDiagonal() == false || b.isDiagonal() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = scalar.multiply(a.getDiagonalElement(j).multiply(b.diagonalElements[j])); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 966 |
org/mklab/sdpj/algebra/Algebra.java | 1051 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1100 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1185 |
"NoTranspose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), scalar, a.denseElements, a.getRowSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: if (ans.isDiagonal() == false || a.isDiagonal() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } int shou = ans.getColumnSize() / 4; int amari = ans.getColumnSize() % 4; for (int j = 0; j < amari; ++j) { ans.diagonalElements[j] = scalar.multiply(a.diagonalElements[j].multiply(b.getDiagonalElement(j))); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1924 |
org/mklab/sdpj/algebra/Algebra.java | 2036 |
org/mklab/sdpj/algebra/Algebra.java | 2374 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2058 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2170 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2508 |
RS value1 = a.getSparseElement(index); if (i1 != j1) { int ij = i1 + ans.getColumnSize() * j1; int ji = j1 + ans.getColumnSize() * i1; ans.denseElements[ij] = ans.denseElements[ij].add(value1); ans.denseElements[ji] = ans.denseElements[ji].add(value1); } else { int ii = i1 + ans.getColumnSize() * i1; ans.denseElements[ii] = ans.denseElements[ii].add(value1); } int i2 = a.rowIndex[index + 1]; |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2148 |
org/mklab/sdpj/algebra/Algebra.java | 2476 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2282 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2610 |
RS value1 = a.getSparseElement(index); if (i1 != j1) { int ij = i1 + ans.getColumnSize() * j1; int ji = j1 + ans.getColumnSize() * i1; ans.denseElements[ij] = ans.denseElements[ij].subtract(value1); ans.denseElements[ji] = ans.denseElements[ji].subtract(value1); } else { int ii = i1 + ans.getColumnSize() * i1; ans.denseElements[ii] = ans.denseElements[ii].subtract(value1); } int i2 = a.rowIndex[index + 1]; |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2299 |
org/mklab/sdpj/algebra/Algebra.java | 2410 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2433 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2544 |
RS value4 = b.getSparseElement(index + 3).multiply(scalar); if (i4 != j4) { int ij = i4 + ans.getColumnSize() * j4; int ji = j4 + ans.getColumnSize() * i4; ans.denseElements[ij] = ans.denseElements[ij].add(value4); ans.denseElements[ji] = ans.denseElements[ji].add(value4); } else { int ii = i4 + ans.getColumnSize() * i4; ans.denseElements[ii] = ans.denseElements[ii].add(value4); } } return ans; case DENSE: |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2548 |
org/mklab/sdpj/algebra/Algebra.java | 2575 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2682 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2709 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockVector<RS,RM,CS,CM> plus(BlockVector<RS,RM,CS,CM> a, BlockVector<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("plus:: different nBlock size"); //$NON-NLS-1$ } RS unit = a.getElementUnit(); BlockVector<RS,RM,CS,CM> ans = new BlockVector<>(a.getBlockSize(), a.getBlockStructs(), unit); for (int i = 0; i < a.getBlockSize(); ++i) { Vector<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i), scalar); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2885 |
org/mklab/sdpj/algebra/Algebra.java | 2913 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3019 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3047 |
BlockDenseMatrix<RS,RM,CS,CM> ans = multiply(a, scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param operator 演算子 * @param b b * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> Vector<RS,RM,CS,CM> let(Vector<RS,RM,CS,CM> a, final char operator, Vector<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3084 |
org/mklab/sdpj/algebra/Algebra.java | 3115 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3218 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3249 |
ans = multiply(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> let(DenseMatrix<RS,RM,CS,CM> a, final char operator, SparseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3148 |
org/mklab/sdpj/algebra/Algebra.java | 3188 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3282 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3322 |
ans = multiply(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' 't' 'T' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockDenseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3228 |
org/mklab/sdpj/algebra/Algebra.java | 3259 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3362 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3393 |
ans = multiply_tran(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockSparseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3291 |
org/mklab/sdpj/algebra/Algebra.java | 3323 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3425 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3457 |
ans = multiply(a, b); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockDenseMatrix<RS,RM,CS,CM> a, final char operator, BlockSparseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dlatrd.java | 340 |
org/mklab/sdpj/gpack/lapackwrap/Dsytd2.java | 332 |
} /** * @param n n * @param alpha a[?] * @param xIndex a * @param incx indx * @param tau tau * @return result */ private RS[] dlarfg(int n, RS alpha, int xIndex, int incx, RS tau) { final RS unit = alpha.createUnit(); RS[] x = unit.createArray(this.a.length - xIndex); System.arraycopy(this.a, xIndex, x, 0, x.length); RS[] ans = Clapack.dlarfg(n, alpha, x, incx, tau); System.arraycopy(x, 0, this.a, xIndex, x.length); return ans; } |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1284 |
org/mklab/sdpj/algebra/Algebra.java | 1333 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1418 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1467 |
Vector<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2584 |
org/mklab/sdpj/algebra/Algebra.java | 2740 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2718 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2874 |
Vector<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans = a + b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1924 |
org/mklab/sdpj/algebra/Algebra.java | 2036 |
org/mklab/sdpj/algebra/Algebra.java | 2263 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2058 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2170 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2397 |
RS value1 = a.getSparseElement(index); if (i1 != j1) { int ij = i1 + ans.getColumnSize() * j1; int ji = j1 + ans.getColumnSize() * i1; ans.denseElements[ij] = ans.denseElements[ij].add(value1); ans.denseElements[ji] = ans.denseElements[ji].add(value1); } else { int ii = i1 + ans.getColumnSize() * i1; ans.denseElements[ii] = ans.denseElements[ii].add(value1); } int i2 = a.rowIndex[index + 1]; |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1936 |
org/mklab/sdpj/algebra/Algebra.java | 2048 |
org/mklab/sdpj/algebra/Algebra.java | 2275 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2070 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2182 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2409 |
RS value2 = a.getSparseElement(index + 1); if (i2 != j2) { int ij = i2 + ans.getColumnSize() * j2; int ji = j2 + ans.getColumnSize() * i2; ans.denseElements[ij] = ans.denseElements[ij].add(value2); ans.denseElements[ji] = ans.denseElements[ji].add(value2); } else { int ii = i2 + ans.getColumnSize() * i2; ans.denseElements[ii] = ans.denseElements[ii].add(value2); } int i3 = a.rowIndex[index + 2]; |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1948 |
org/mklab/sdpj/algebra/Algebra.java | 2060 |
org/mklab/sdpj/algebra/Algebra.java | 2287 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2082 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2194 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2421 |
RS value3 = a.getSparseElement(index + 2); if (i3 != j3) { int ij = i3 + ans.getColumnSize() * j3; int ji = j3 + ans.getColumnSize() * i3; ans.denseElements[ij] = ans.denseElements[ij].add(value3); ans.denseElements[ji] = ans.denseElements[ji].add(value3); } else { int ii = i3 + ans.getColumnSize() * i3; ans.denseElements[ii] = ans.denseElements[ii].add(value3); } int i4 = a.rowIndex[index + 3]; |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dlasr.java | 165 |
org/mklab/sdpj/gpack/lapackwrap/Dlasr.java | 179 |
if (!ctemp.isUnit() || stemp.isZero()) { for (int i = 1; i <= n; ++i) { int p1 = i * a_dim1 + j + pointer_a; int p2 = i * a_dim1 + j + 1 + pointer_a; RS temp = a[p2]; a[p2] = (ctemp.multiply(temp)).subtract(stemp.multiply(a[p1])); a[p1] = (stemp.multiply(temp)).add(ctemp.multiply(a[p1])); } } } } else if (BLAS.lsame(direct, "B")) { //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2584 |
org/mklab/sdpj/algebra/Algebra.java | 2636 |
org/mklab/sdpj/algebra/Algebra.java | 2714 |
org/mklab/sdpj/algebra/Algebra.java | 2793 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2718 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2770 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2848 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2927 |
Vector<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans = a + b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 366 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 456 |
return (RS)result.toMPFloatWithDefaultPrecision(); } for (int i = 0; i < a.getBlockSize(); ++i) { ans = ans.add(getInnerProduct(a.getBlock(i), b.getBlock(i))); } return ans; } /** * 内積の計算を行います。 Al.getInnerProduct(ret,aVec,bVec)をret=Al.getInnerProduct(aVec,bVec)に変更。 * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 内積 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> RS getInnerProduct(BlockSparseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/blaswrap/BLAS.java | 133 |
org/mklab/sdpj/gpack/blaswrap/BLAS.java | 449 |
return new Ddot<RS,RM,CS,CM>().ddot(n, dx, incx, dy, incy); } /** * C := alpha*op(A)*op(B)+beta*C * * @param <RS> 実スカラーの型 * @param <RM> 実行列の型 * @param <CS> 複素スカラーの型 * @param <CM> 複素行列の型 * @param transa transa * @param transb transb * @param m op(A)とCの列数 * @param n op(B)とCの行数 * @param k op(A)の行数と op(B)の列数 * @param alpha alpha * @param a a * @param lda transa = 'n' then max(1,m),otherwise max(1,k) * @param b b * @param ldb transb = 'n' then max(1,k), otherwise max(1,n) * @param beta beta * @param c c * @param ldc max(1,m) * @return result */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> int dgemm(String transa, String transb, int m, int n, int k, RS alpha, RS[] a, int lda, RS[] b, int ldb, RS beta, RS[] c, int ldc) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dpotf2.java | 88 |
org/mklab/sdpj/gpack/lapackwrap/Dpotrf.java | 85 |
RS c_b12 = unit.create(1); int a_dim1 = lda; int a_offset = 1 + a_dim1 * 1; int pointer_a = -a_offset; /* Function Body */ int info = 0; boolean upper = BLAS.lsame(uplo, "U"); //$NON-NLS-1$ if (!upper && !BLAS.lsame(uplo, "L")) { //$NON-NLS-1$ info = -1; } else if (n < 0) { info = -2; } else if (lda < Math.max(1, n)) { info = -4; } if (info != 0) { BLAS.xerbla("DPOTF2", -info); //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 728 |
org/mklab/sdpj/algebra/Algebra.java | 813 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 862 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 947 |
ans.diagonalElements[j + 3] = a.diagonalElements[j + 3].multiply(b.diagonalElements[j + 3]); } return ans; default: throw new IllegalArgumentException(); } } /** * Dense=Sparse*Dense * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply(SparseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 898 |
org/mklab/sdpj/algebra/Algebra.java | 985 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1032 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1119 |
ans.diagonalElements[j + 3] = a.getDiagonalElement(j + 3).multiply(b.diagonalElements[j + 3]); } return ans; default: throw new IllegalArgumentException(); } } /** * TODO MULTIPLY_NON_ATLASがFalseの場合でやるのもいいかも。 falseの場合でやると、配列のコピーの回数がここの分だけ減る。 Dense=Dense*Sparse * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> multiply(DenseMatrix<RS,RM,CS,CM> a, SparseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1284 |
org/mklab/sdpj/algebra/Algebra.java | 1309 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1418 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1443 |
Vector<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1301 |
org/mklab/sdpj/algebra/Algebra.java | 1399 |
org/mklab/sdpj/algebra/Algebra.java | 1423 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1435 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1533 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1557 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i), scalar); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1333 |
org/mklab/sdpj/algebra/Algebra.java | 1358 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1467 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1492 |
DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockSparseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1350 |
org/mklab/sdpj/algebra/Algebra.java | 1374 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1484 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1508 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockSparseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(b.getBlockSize(), b.getBlockStructs(), b.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i), scalar); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1382 |
org/mklab/sdpj/algebra/Algebra.java | 1407 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1516 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1541 |
DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockSparseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1540 |
org/mklab/sdpj/algebra/Algebra.java | 1564 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1674 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1698 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> tran_multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = tran_multiply(a.getBlock(i), b.getBlock(i), scalar); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1899 |
org/mklab/sdpj/algebra/Algebra.java | 2011 |
org/mklab/sdpj/algebra/Algebra.java | 2123 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2033 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2145 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2257 |
throw new RuntimeException("plus :: different matrix type"); //$NON-NLS-1$ } int shou = a.nonZeroCount / 4; int amari = a.nonZeroCount % 4; for (int index = 0; index < amari; ++index) { int i = a.rowIndex[index]; int j = a.columnIndex[index]; RS value = a.getSparseElement(index); if (i != j) { int ij = i + ans.getColumnSize() * j; int ji = j + ans.getColumnSize() * i; ans.denseElements[ij] = ans.denseElements[ij].add(value); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2584 |
org/mklab/sdpj/algebra/Algebra.java | 2611 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2718 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2745 |
Vector<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans = a + b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2603 |
org/mklab/sdpj/algebra/Algebra.java | 2629 |
org/mklab/sdpj/algebra/Algebra.java | 2759 |
org/mklab/sdpj/algebra/Algebra.java | 2785 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2737 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2763 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2893 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2919 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("plus:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i), scalar); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2661 |
org/mklab/sdpj/algebra/Algebra.java | 2688 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2795 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2822 |
DenseMatrix<RS,RM,CS,CM> blockAns = minus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans = a + b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockSparseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2680 |
org/mklab/sdpj/algebra/Algebra.java | 2706 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2814 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2840 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockSparseMatrix<RS,RM,CS,CM> a, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("plus:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(b.getBlockSize(), b.getBlockStructs(), b.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = plus(a.getBlock(i), b.getBlock(i), scalar); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2740 |
org/mklab/sdpj/algebra/Algebra.java | 2767 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2874 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2901 |
DenseMatrix<RS,RM,CS,CM> blockAns = minus(a.getBlock(i), b.getBlock(i)); ans.setBlock(i, blockAns); } return ans; } /** * ans + a * b*scalar * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> plus(BlockDenseMatrix<RS,RM,CS,CM> a, BlockSparseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2963 |
org/mklab/sdpj/algebra/Algebra.java | 3169 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3097 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3303 |
DenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b, scalar); return ans; case '-': final RS minus_scalar = scalar.unaryMinus(); ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b, scalar); return ans; case 't': // ret = aMat**T * bMat ans = tran_multiply(a, b, scalar); return ans; case 'T': // ret = aMat * bMat**T ans = multiply_tran(a, b, scalar); return ans; default: throw new IllegalArgumentException("let:: operator error"); //$NON-NLS-1$ |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3188 |
org/mklab/sdpj/algebra/Algebra.java | 3323 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3322 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3457 |
ans = multiply_tran(a, b, scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' 't' 'T' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockDenseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/iocenter/SolverIO.java | 358 |
org/mklab/sdpj/iocenter/SolverIO.java | 363 |
this.Display.printf("%2d %s %s %s %s %s %s %s %s\n", this.pIteration, this.mu.getValue().toString(), this.theta.getPrimal().toString(), this.theta.getDual().toString(), //$NON-NLS-1$ this.solveInfo.getObjValPrimal().toString(), this.solveInfo.getObjValDual().toString(), this.alpha.getPrimal().toString(), this.alpha.getDual().toString(), this.beta.getValue().toString()); } |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1115 |
org/mklab/sdpj/algebra/Algebra.java | 1150 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1249 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1284 |
DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), scalar); ans.setBlock(i, blockAns); } return ans; } /** * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a a * @param scalar スカラー * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> Vector<RS,RM,CS,CM> multiply(Vector<RS,RM,CS,CM> a, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1399 |
org/mklab/sdpj/algebra/Algebra.java | 1540 |
org/mklab/sdpj/algebra/Algebra.java | 1682 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1533 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1674 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1816 |
private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> multiply(BlockDenseMatrix<RS,RM,CS,CM> a, BlockSparseMatrix<RS,RM,CS,CM> b, RS scalar) { if (a.getBlockSize() != b.getBlockSize()) { throw new RuntimeException("multiply:: different nBlock size"); //$NON-NLS-1$ } BlockDenseMatrix<RS,RM,CS,CM> ans = new BlockDenseMatrix<>(a.getBlockSize(), a.getBlockStructs(), a.getUnit()); for (int i = 0; i < a.getBlockSize(); ++i) { DenseMatrix<RS,RM,CS,CM> blockAns = multiply(a.getBlock(i), b.getBlock(i), scalar); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1801 |
org/mklab/sdpj/algebra/Algebra.java | 2207 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1935 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2341 |
BLAS.daxpy(ans.getColumnSize(), scalar, b.diagonalElements, 1, ans.diagonalElements, 1); return ans; default: throw new IllegalArgumentException(); } } /** * ans = a + b * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param b B * @return 解 */ private static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> plus(DenseMatrix<RS,RM,CS,CM> a, DenseMatrix<RS,RM,CS,CM> b) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 1915 |
org/mklab/sdpj/algebra/Algebra.java | 2027 |
org/mklab/sdpj/algebra/Algebra.java | 2139 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2049 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2161 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2273 |
ans.denseElements[ii] = ans.denseElements[ii].add(value); } } int index; int counter; for (index = amari, counter = 0; counter < shou; ++counter, index += 4) { int i1 = a.rowIndex[index]; int j1 = a.columnIndex[index]; RS value1 = a.getSparseElement(index); if (i1 != j1) { int ij = i1 + ans.getColumnSize() * j1; int ji = j1 + ans.getColumnSize() * i1; ans.denseElements[ij] = ans.denseElements[ij].add(value1); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2365 |
org/mklab/sdpj/algebra/Algebra.java | 2467 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2499 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 2601 |
ans.denseElements[ii] = ans.denseElements[ii].add(value); } } int index; int counter; for (index = amari, counter = 0; counter < shou; ++counter, index += 4) { int i1 = b.rowIndex[index]; int j1 = b.columnIndex[index]; RS value1 = b.getSparseElement(index); if (i1 != j1) { int ij = i1 + ans.getColumnSize() * j1; int ji = j1 + ans.getColumnSize() * i1; ans.denseElements[ij] = ans.denseElements[ij].add(value1); |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2962 |
org/mklab/sdpj/algebra/Algebra.java | 3041 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3096 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3175 |
public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> let(DenseMatrix<RS,RM,CS,CM> a, final char operator, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { DenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b, scalar); return ans; case '-': final RS minus_scalar = scalar.unaryMinus(); ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b, scalar); return ans; |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 3168 |
org/mklab/sdpj/algebra/Algebra.java | 3248 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3302 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3382 |
public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> BlockDenseMatrix<RS,RM,CS,CM> let(BlockDenseMatrix<RS,RM,CS,CM> a, final char operator, BlockDenseMatrix<RS,RM,CS,CM> b, RS scalar) { BlockDenseMatrix<RS,RM,CS,CM> ans; switch (operator) { case '+': ans = plus(a, b, scalar); return ans; case '-': final RS minus_scalar = scalar.unaryMinus(); ans = plus(a, b, minus_scalar); return ans; case '*': ans = multiply(a, b, scalar); return ans; |
File | Line |
---|---|
org/mklab/sdpj/gpack/blaswrap/Dgemm.java | 129 |
org/mklab/sdpj/gpack/blaswrap/Dsyr2k.java | 133 |
int dgemm(String transa, String transb, int m, int n, int k, RS alpha, RS[] a, int lda, RS[] b, int ldb, RS beta, RS[] c, int ldc) { final RS unit = a[0].createUnit(); int a_dim1 = lda; int a_offset = 1 + a_dim1 * 1; int pointer_a = -a_offset; int b_dim1 = ldb; int b_offset = 1 + b_dim1 * 1; int pointer_b = -b_offset; int c_dim1 = ldc; int c_offset = 1 + c_dim1 * 1; int pointer_c = -c_offset; |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 875 |
org/mklab/sdpj/algebra/Algebra.java | 1047 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1009 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 1181 |
if (ans.isDense() == false || b.isDense() == false) { throw new RuntimeException("multiply :: different matrix type"); //$NON-NLS-1$ } BLAS.dgemm( "NoTranspose", "NoTranspose", ans.getRowSize(), ans.getColumnSize(), a.getColumnSize(), unit.create(1), a.denseElements, a.getRowSize(), b.denseElements, b.getRowSize(), unit.create(0), ans.denseElements, //$NON-NLS-1$ //$NON-NLS-2$ ans.getRowSize()); return ans; case DIAGONAL: if (ans.isDiagonal() == false || b.isDiagonal() == false) { |
File | Line |
---|---|
org/mklab/sdpj/algebra/Algebra.java | 2939 |
org/mklab/sdpj/algebra/Algebra.java | 3084 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3073 |
org/mklab/sdpj/algebra/AlgebraWithEFFloat.java | 3218 |
ans = minus(a, b); //final RS unit = a.getElementUnit(); //final RS minus_scalar = unit.create(-1); //ans = plus(a, b, minus_scalar); return ans; default: throw new RuntimeException("let:: operator error"); //$NON-NLS-1$ } } /** * ans = a '+' '-' '*' 't' 'T' b*(*scalar) * * @param <RS> type of real scalar * @param <RM> type of real matrix * @param <CS> type of complex scalar * @param <CM> type of complex Matrix * @param a A * @param operator 演算子 * @param b B * @param scalar スカラー * @return 解 */ public static <RS extends RealNumericalScalar<RS, RM, CS, CM>, RM extends RealNumericalMatrix<RS, RM, CS, CM>, CS extends ComplexNumericalScalar<RS, RM, CS, CM>, CM extends ComplexNumericalMatrix<RS, RM, CS, CM>> DenseMatrix<RS,RM,CS,CM> let(DenseMatrix<RS,RM,CS,CM> a, final char operator, DenseMatrix<RS,RM,CS,CM> b, RS scalar) { |
File | Line |
---|---|
org/mklab/sdpj/gpack/lapackwrap/Dorgtr.java | 291 |
org/mklab/sdpj/gpack/lapackwrap/Dorgtr.java | 732 |
if (m < 0) { info = -1; } else if (n < 0 || n > m) { info = -2; } else if (k < 0 || k > n) { info = -3; } else if (lda < Math.max(1, m)) { info = -5; } else if (lwork < Math.max(1, n) && !lquery) { info = -8; } if (info != 0) { BLAS.xerbla("DORGQL", -info); //$NON-NLS-1$ |