public static void centerColum(DoubleMatrix2D mat) { System.out.println("Standardizing probe mean"); for (int c = 0; c < mat.columns(); c++) { double mean = Descriptives.mean(mat.viewColumn(c).toArray()); for (int r = 0; r < mat.rows(); r++) { mat.set(r, c, ((mat.getQuick(r, c) - mean))); } } }
public static Pair<Integer, Integer> getIndexOfFirstZeroIgnoreDiagonal(DoubleMatrix2D a) { for (int i = 0; i < a.rows(); i++) { for (int j = 0; j < a.columns(); j++) { if (i != j && a.get(i, j) == 0) { return new Pair<Integer, Integer>(i, j); } } } return null; }
public static Pair<Integer, Integer> getIndexOfFirstNegative(DoubleMatrix2D a) { for (int i = 0; i < a.rows(); i++) { for (int j = 0; j < a.columns(); j++) { if (a.get(i, j) < 0) { return new Pair<Integer, Integer>(i, j); } } } return null; }
public static boolean containsNaNs(DoubleMatrix2D a) { for (int i = 0; i < a.rows(); i++) { for (int j = 0; j < a.columns(); j++) { if (Double.isNaN(a.get(i, j))) { return true; } } } return false; }
public static void rankColumns(DoubleMatrix2D matrix) { RankingAlgorithm COV_RANKER_TIE = new NaturalRanking(NaNStrategy.FAILED, TiesStrategy.AVERAGE); for (int c = 0; c < matrix.columns(); c++) { double[] rank = COV_RANKER_TIE.rank(matrix.viewColumn(c).toArray()); for (int r = 0; r < matrix.rows(); r++) { matrix.set(r, c, (rank[r])); } } }
public static void scaleColum(DoubleMatrix2D mat) { System.out.println("Standardizing probe standard deviation"); for (int c = 0; c < mat.columns(); c++) { double[] t = mat.viewColumn(c).toArray(); double mean = Descriptives.mean(t); double stdev = Math.sqrt(Descriptives.variance(t, mean)); for (int r = 0; r < mat.rows(); r++) { mat.set(r, c, ((mat.getQuick(r, c)) / stdev)); } } }
private double gcvTsvdDCT2D(DoubleMatrix2D S, DoubleMatrix2D Bhat) { int length = S.rows() * S.columns(); DoubleMatrix1D s = new DenseDoubleMatrix1D(length); DoubleMatrix1D bhat = new DenseDoubleMatrix1D(length); System.arraycopy( ((DenseDoubleMatrix2D) S).elements(), 0, ((DenseDoubleMatrix1D) s).elements(), 0, length); System.arraycopy( ((DenseDoubleMatrix2D) Bhat).elements(), 0, ((DenseDoubleMatrix1D) bhat).elements(), 0, length); s.assign(DoubleFunctions.abs); bhat.assign(DoubleFunctions.abs); final double[] svalues = (double[]) ((DenseDoubleMatrix1D) s).elements(); IntComparator compDec = new IntComparator() { public int compare(int a, int b) { if (svalues[a] != svalues[a] || svalues[b] != svalues[b]) return compareNaN(svalues[a], svalues[b]); // swap NaNs to // the end return svalues[a] < svalues[b] ? 1 : (svalues[a] == svalues[b] ? 0 : -1); } }; int[] indices = DoubleSorting.quickSort.sortIndex(s, compDec); s = s.viewSelection(indices); bhat = bhat.viewSelection(indices); int n = s.size(); double[] rho = new double[n - 1]; rho[n - 2] = bhat.getQuick(n - 1) * bhat.getQuick(n - 1); DoubleMatrix1D G = new DenseDoubleMatrix1D(n - 1); double[] elemsG = (double[]) G.elements(); elemsG[n - 2] = rho[n - 2]; double bhatel, temp1; for (int k = n - 2; k > 0; k--) { bhatel = bhat.getQuick(k); rho[k - 1] = rho[k] + bhatel * bhatel; temp1 = n - k; temp1 = temp1 * temp1; elemsG[k - 1] = rho[k - 1] / temp1; } for (int k = 0; k < n - 3; k++) { if (s.getQuick(k) == s.getQuick(k + 1)) { elemsG[k] = Double.POSITIVE_INFINITY; } } return s.getQuick((int) G.getMinLocation()[1]); }
/** * Solves for bus voltages given the full system admittance matrix (for all buses), the complex * bus power injection vector (for all buses), the initial vector of complex bus voltages, and * column vectors with the lists of bus indices for the swing bus, PV buses, and PQ buses, * respectively. The bus voltage vector contains the set point for generator (including ref bus) * buses, and the reference angle of the swing bus, as well as an initial guess for remaining * magnitudes and angles. JPOPT is a JPOWER options vector which can be used to set the * termination tolerance, maximum number of iterations, and output options (see JPOPTION for * details). Uses default options if this parameter is not given. Returns the final complex * voltages, a flag which indicates whether it converged or not, and the number of iterations * performed. * * @param Ybus * @param Sbus * @param V0 * @param ref * @param pv * @param pq * @param jpopt * @return */ @SuppressWarnings("static-access") public static Object[] jp_newtonpf( DComplexMatrix2D Ybus, DComplexMatrix1D Sbus, DComplexMatrix1D V0, int ref, int[] pv, int[] pq, Map<String, Double> jpopt) { int i, max_it, verbose, npv, npq, j1, j2, j3, j4, j5, j6; int[] pvpq; double tol, normF; boolean converged; DoubleMatrix1D F, dx; DoubleMatrix2D J11, J12, J21, J22, J1, J2, J; DComplexMatrix1D mis, V, Va, Vm, dxz; DComplexMatrix2D dSbus_dVm, dSbus_dVa; DComplexMatrix2D[] dSbus_dV; SparseRCDoubleMatrix2D JJ; /* options */ tol = jpopt.get("PF_TOL"); max_it = jpopt.get("PF_MAX_IT").intValue(); verbose = jpopt.get("VERBOSE").intValue(); /* initialize */ pvpq = Djp_util.icat(pv, pq); converged = false; i = 0; V = V0; Va = V.copy().assign(cfunc.arg); Vm = V.copy().assign(cfunc.abs); /* set up indexing for updating V */ npv = pv.length; npq = pq.length; j1 = 0; j2 = npv; // j1:j2 - V angle of pv buses j3 = j2; j4 = j2 + npq; // j3:j4 - V angle of pq buses j5 = j4; j6 = j4 + npq; // j5:j6 - V mag of pq buses /* evaluate F(x0) */ mis = Ybus.zMult(V, null).assign(cfunc.conj); mis.assign(V, cfunc.mult).assign(Sbus, cfunc.minus); F = DoubleFactory1D.sparse.make( new DoubleMatrix1D[] { mis.viewSelection(pvpq).getRealPart(), mis.viewSelection(pq).getImaginaryPart() }); /* check tolerance */ normF = DenseDoubleAlgebra.DEFAULT.norm(F, Norm.Infinity); if (verbose > 0) System.out.print("(Newton)\n"); if (verbose > 1) { System.out.printf("\n it max P & Q mismatch (p.u.)"); System.out.printf("\n---- ---------------------------"); System.out.printf("\n%3d %10.3e", i, normF); } if (normF < tol) { converged = true; if (verbose > 1) System.out.printf("\nConverged!\n"); } /* do Newton iterations */ while ((!converged) & (i < max_it)) { /* update iteration counter */ i += 1; /* evaluate Jacobian */ dSbus_dV = Djp_dSbus_dV.jp_dSbus_dV(Ybus, V); dSbus_dVm = dSbus_dV[0]; dSbus_dVa = dSbus_dV[1]; J11 = dSbus_dVa.getRealPart().viewSelection(pvpq, pvpq).copy(); J12 = dSbus_dVm.getRealPart().viewSelection(pvpq, pq).copy(); J21 = dSbus_dVa.getImaginaryPart().viewSelection(pq, pvpq).copy(); J22 = dSbus_dVm.getImaginaryPart().viewSelection(pq, pq).copy(); J1 = DoubleFactory2D.sparse.appendColumns(J11, J12); J2 = DoubleFactory2D.sparse.appendColumns(J21, J22); J = DoubleFactory2D.sparse.appendRows(J1, J2); JJ = new SparseRCDoubleMatrix2D(J.rows(), J.columns()); JJ.assign(J); dx = SparseDoubleAlgebra.DEFAULT.solve(JJ, F).assign(dfunc.neg); dxz = Djp_util.complex(dx, null); /* update voltage */ if (npv > 0) Va.viewSelection(pv).assign(dxz.viewSelection(Djp_util.irange(j1, j2)), cfunc.plus); if (npq > 0) { Va.viewSelection(pq).assign(dxz.viewSelection(Djp_util.irange(j3, j4)), cfunc.plus); Vm.viewSelection(pq).assign(dxz.viewSelection(Djp_util.irange(j5, j6)), cfunc.plus); } V = Djp_util.polar(Vm.getRealPart(), Va.getRealPart()); /* update Vm and Va again in case we wrapped around with a negative Vm */ Va = V.copy().assign(cfunc.arg); Vm = V.copy().assign(cfunc.abs); /* evalute F(x) */ mis = Ybus.zMult(V, null).assign(cfunc.conj); mis.assign(V, cfunc.mult).assign(Sbus, cfunc.minus); F = DoubleFactory1D.sparse.make( new DoubleMatrix1D[] { mis.viewSelection(pvpq).getRealPart(), mis.viewSelection(pq).getImaginaryPart() }); /* check for convergence */ normF = DenseDoubleAlgebra.DEFAULT.norm(F, Norm.Infinity); if (verbose > 1) System.out.printf("\n%3d %10.3e", i, normF); if (normF < tol) { converged = true; if (verbose > 0) System.out.printf("\nNewton's method power flow converged in %d iterations.\n", i); } } if (verbose > 0) if (!converged) System.out.printf("\nNewton''s method power did not converge in %d iterations.\n", i); return new Object[] {V, converged, i}; }