List of usage examples for org.apache.commons.math3.linear RealVector subtract
public RealVector subtract(RealVector v) throws DimensionMismatchException
From source file:org.rhwlab.variationalbayesian.SuperVoxelGaussianMixture.java
public void statistics() { // calculate N for (int k = 0; k < K; ++k) { N[k] = 0.0;//from w w w . j a va 2s .c om for (int n = 0; n < X.getN(); ++n) { SuperVoxel sv = X.get(n); N[k] = N[k] + sv.getVoxels().length * r.getEntry(n, k); } N[k] = N[k] + .000001; } // calculate xBar for (int k = 0; k < K; ++k) { xBar[k].set(0.0); for (int n = 0; n < X.getN(); ++n) { SuperVoxel sv = X.get(n); double rnk = r.getEntry(n, k); RealVector x = sv.getCenter().mapMultiply(rnk * sv.getVoxels().length); xBar[k] = xBar[k].add(x); } xBar[k].mapDivideToSelf(N[k]); } // calculate the S for (int k = 0; k < K; ++k) { for (int row = 0; row < X.getD(); ++row) { for (int col = 0; col < X.getD(); ++col) { S[k].setEntry(row, col, 0.0); } } for (int n = 0; n < X.getN(); ++n) { SuperVoxel sv = X.get(n); for (RealVector vox : sv.getVoxels()) { RealVector del = vox.subtract(xBar[k]); S[k] = S[k].add(del.outerProduct(del).scalarMultiply(r.getEntry(n, k))); } } S[k] = S[k].scalarMultiply(1.0 / N[k]); } }
From source file:RBFNN.MainFrame.java
public static RealMatrix RBFtrain(ArrayList<instance> trainingdata) { RealMatrix W = MatrixUtils.createRealMatrix(K, 1); int n = K;//denotes the number of hidden layer neurons int m = trainingdata.size(); Dmax = Dmax(centers);//w w w. j ava 2s .c o m double[][] hiddenout = new double[n][m]; for (int i = 0; i < n; i++) {//compute the output matrix of hidden neurons RealVector cen = MatrixUtils.createRealVector(centers.get(i).getnumFeature()); double[] outCol = new double[m]; for (int j = 0; j < m; j++) { double[] Xi = trainingdata.get(j).getnumFeature(); RealVector Xii = MatrixUtils.createRealVector(Xi); outCol[j] = Math.exp(-Math.pow(Xii.subtract(cen).getNorm(), 2) * K / (Dmax * Dmax)); //employ the Guassian function to implement } hiddenout[i] = outCol; } RealMatrix hiddenoutM = MatrixUtils.createRealMatrix(hiddenout);//n*m double[][] Yexp = new double[m][1]; for (int j = 0; j < m; j++) { Yexp[j][0] = trainingdata.get(j).getnumcls(); } RealMatrix YexpM = MatrixUtils.createRealMatrix(Yexp);//size: m*1 Matrix hiddenM = new Matrix(hiddenoutM.transpose().getData());//change to another matrix library Matrix pseuInversHM = MoorePenroseInverse.pinv(hiddenM); RealMatrix pseuInversRM = MatrixUtils.createRealMatrix(pseuInversHM.getArray()); W = pseuInversRM.multiply(YexpM);//size: n*1 or K*1 return W; }
From source file:RBFNN.MainFrame.java
public static int[] RBFtest(RealMatrix W, ArrayList<instance> testingdata, double accuracy) { //return four elements in the confusion Matrix int n = K;//denotes the number of hidden layer neurons int m = testingdata.size(); double[][] hiddenout = new double[n][m]; int[] confusion = new int[4]; for (int i = 0; i < K; i++) {//compute the output matrix of hidden neurons RealVector cen = MatrixUtils.createRealVector(centers.get(i).getnumFeature()); double[] outCol = new double[m]; for (int j = 0; j < m; j++) { double[] Xi = testingdata.get(j).getnumFeature(); RealVector Xii = MatrixUtils.createRealVector(Xi); outCol[j] = Math.exp(-Math.pow(Xii.subtract(cen).getNorm(), 2) * K / (Dmax * Dmax)); //employ the Guassian function to implement }//from w w w. ja v a 2 s .com hiddenout[i] = outCol; } RealMatrix hiddenoutM = MatrixUtils.createRealMatrix(hiddenout);//n*m RealMatrix YactM = hiddenoutM.transpose().multiply(W); double[][] Yexp = new double[m][1]; for (int j = 0; j < m; j++) { Yexp[j][0] = testingdata.get(j).getnumcls(); } RealMatrix YexpM = MatrixUtils.createRealMatrix(Yexp);//size: m*1 confusion = compare(YactM, YexpM); return confusion; }
From source file:rcdemo.track.TrackODE.java
@Override public void computeSecondDerivatives(double t, double[] y, double[] yDot, double[] yDDot) { double s = y[0]; double dsdt = yDot[0]; RealVector x = track.getx(s);//from ww w . jav a 2s. co m RealVector dxds = track.getDxDs(s); RealVector ddxdss = track.getDDxDss(s); RealVector u = dxds; RealVector v = dxds.mapMultiply(dsdt); RealVector F = forceModel.getForce(x, v); double ddsdtt = F.subtract(ddxdss.mapMultiply(dsdt * dsdt)).dotProduct(u) / dxds.dotProduct(u); //double E = 0.5 * v.dotProduct(v) + forceModel.getPotentialEnergy(x, v); //System.out.format("%4.1f: %s %s %s\n", t, s, x, E); //System.out.format("%7.5f: %s %s %s\n", t, s, x, E); yDDot[0] = ddsdtt; }
From source file:scorePairing.ScorePairingWithStaticMethods.java
public static ResultFromScorePairing computeCost(PairingAndNullSpaces currentNewPairingAndNewNullSpaces, Map<Integer, PointWithPropertiesIfc> queryShape, Map<Integer, PointWithPropertiesIfc> hitShape, AlgoParameters algoParameters) { int countOfPairedPoint = currentNewPairingAndNewNullSpaces.getPairing().size(); double[][] matrixPointsModelDouble = new double[3][countOfPairedPoint]; double[][] matrixPointsCandidateDouble = new double[3][countOfPairedPoint]; RealMatrix matrixPointsModel = new Array2DRowRealMatrix(matrixPointsModelDouble); RealMatrix matrixPointsCandidate = new Array2DRowRealMatrix(matrixPointsCandidateDouble); int currentPoint = 0; RealVector sumVector1 = new ArrayRealVector(new double[3]); RealVector sumVector2 = new ArrayRealVector(new double[3]); sumVector1.setEntry(0, 0.0);/*w w w.j av a 2 s . c o m*/ sumVector1.setEntry(1, 0.0); sumVector1.setEntry(2, 0.0); sumVector2.setEntry(0, 0.0); sumVector2.setEntry(1, 0.0); sumVector2.setEntry(2, 0.0); for (Map.Entry<Integer, Integer> entry : currentNewPairingAndNewNullSpaces.getPairing().entrySet()) { Integer point1id = Integer.valueOf(entry.getKey().intValue()); Integer point2id = Integer.valueOf(entry.getValue().intValue()); // the 2 points could be defined as static be static PointWithPropertiesIfc point1 = queryShape.get(point1id); PointWithPropertiesIfc point2 = hitShape.get(point2id); // matrix for procrustes matrixPointsModel.setEntry(0, currentPoint, point1.getCoords().getCoords()[0]); matrixPointsModel.setEntry(1, currentPoint, point1.getCoords().getCoords()[1]); matrixPointsModel.setEntry(2, currentPoint, point1.getCoords().getCoords()[2]); matrixPointsCandidate.setEntry(0, currentPoint, point2.getCoords().getCoords()[0]); matrixPointsCandidate.setEntry(1, currentPoint, point2.getCoords().getCoords()[1]); matrixPointsCandidate.setEntry(2, currentPoint, point2.getCoords().getCoords()[2]); // barycenter computation sumVector1.addToEntry(0, point1.getCoords().getCoords()[0]); sumVector1.addToEntry(1, point1.getCoords().getCoords()[1]); sumVector1.addToEntry(2, point1.getCoords().getCoords()[2]); sumVector2.addToEntry(0, point2.getCoords().getCoords()[0]); sumVector2.addToEntry(1, point2.getCoords().getCoords()[1]); sumVector2.addToEntry(2, point2.getCoords().getCoords()[2]); currentPoint += 1; } RealVector barycenterVector1 = sumVector1.mapDivide((double) currentPoint); RealVector barycenterVector2 = sumVector2.mapDivide((double) currentPoint); RealVector translationVectorToTranslateShape2ToOrigin = barycenterVector2.mapMultiply(-1.0); RealVector translationVectorToTranslateShape2ToShape1 = barycenterVector1.subtract(barycenterVector2); translateBarycenterListOfPointToOrigin(matrixPointsModel, barycenterVector1); translateBarycenterListOfPointToOrigin(matrixPointsCandidate, barycenterVector2); ProcrustesAnalysisIfc procrustesAnalysis = null; try { procrustesAnalysis = algoParameters.procrustesAnalysisBuffer.get(); } catch (InterruptedException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } procrustesAnalysis.run(matrixPointsModel, matrixPointsCandidate); RealMatrix rotationMatrixToRotateShape2ToShape1 = procrustesAnalysis.getRotationMatrix(); try { algoParameters.procrustesAnalysisBuffer.put(procrustesAnalysis); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } // not used: we dont really care how accurate is the overlap of points in pairs as it is within expected range because of the // fact that I extend hits with a distance criteria double distanceResidual = procrustesAnalysis.getResidual(); // no need to use hit coverage as already used as a filter // no need to use the distance to outside as it is used as a filter // handling of probability to have a small contribution of if float toleranceElectronProbability = 0.2f; // use only properties for cost double costCharge = 0.0; double costHydrophobicity = 0.0; double costHbondDonnor = 0.0; double costHbondAcceptor = 0.0; double costDehydron = 0.0; double costAromaticRing = 0.0; double costProbabilityDiff = 0.0; for (Map.Entry<Integer, Integer> entry : currentNewPairingAndNewNullSpaces.getPairing().entrySet()) { Integer idFromMap1 = entry.getKey(); Integer idFromMap2 = entry.getValue(); PointWithPropertiesIfc point1 = queryShape.get(idFromMap1); PointWithPropertiesIfc point2 = hitShape.get(idFromMap2); float probabilityOfPoint1 = point1.getElectronProbability(); float probabilityOfPoint2 = point2.getElectronProbability(); float probabilityDiff = Math.abs(probabilityOfPoint1 - probabilityOfPoint2); if (probabilityDiff < toleranceElectronProbability) { probabilityDiff = 0.0f; } else { probabilityDiff -= toleranceElectronProbability; } costProbabilityDiff += probabilityDiff; // handle multi properties // Hydrophobe and Aromatic Float hydrophobicityOfPointFromMap1 = point1.get(PropertyName.Hydrophobicity); Float hydrophobicityOfPointFromMap2 = point2.get(PropertyName.Hydrophobicity); Float aromaticRingOfPointFromMap1 = point1.get(PropertyName.AromaticRing); Float aromaticRingOfPointFromMap2 = point2.get(PropertyName.AromaticRing); // if aromatic it is hydrophobe as well by definition if (aromaticRingOfPointFromMap1 != null && hydrophobicityOfPointFromMap1 == null) { System.out.println(aromaticRingOfPointFromMap1 != null && hydrophobicityOfPointFromMap1 == null); } if (aromaticRingOfPointFromMap2 != null && hydrophobicityOfPointFromMap2 == null) { System.out.println(aromaticRingOfPointFromMap2 != null && hydrophobicityOfPointFromMap2 == null); } // if one hydrophobe and not the other one // then cost hydrophobe if (hydrophobicityOfPointFromMap1 != null && hydrophobicityOfPointFromMap2 == null) { costHydrophobicity += returnCost(hydrophobicityOfPointFromMap1, hydrophobicityOfPointFromMap2); } if (hydrophobicityOfPointFromMap2 != null && hydrophobicityOfPointFromMap1 == null) { costHydrophobicity += returnCost(hydrophobicityOfPointFromMap1, hydrophobicityOfPointFromMap2); } // so a difference of hydrophobe to aromatic is neglected !!! Float chargeOfPointFromMap1 = point1.get(PropertyName.FormalCharge); Float chargeOfPointFromMap2 = point2.get(PropertyName.FormalCharge); costCharge += returnCost(chargeOfPointFromMap1, chargeOfPointFromMap2); Float hBondDonnorOfPointFromMap1 = point1.get(PropertyName.HbondDonnor); Float hBondDonnorOfPointFromMap2 = point2.get(PropertyName.HbondDonnor); Float hBondAcceptorOfPointFromMap1 = point1.get(PropertyName.HbondAcceptor); Float hBondAcceptorOfPointFromMap2 = point2.get(PropertyName.HbondAcceptor); costHbondDonnor += returnCost(hBondDonnorOfPointFromMap1, hBondDonnorOfPointFromMap2); costHbondAcceptor += returnCost(hBondAcceptorOfPointFromMap1, hBondAcceptorOfPointFromMap2); Float dehydronOfPointFromMap1 = point1.get(PropertyName.Dehydron); Float dehydronOfPointFromMap2 = point2.get(PropertyName.Dehydron); costDehydron += returnCost(dehydronOfPointFromMap1, dehydronOfPointFromMap2); } int size = currentNewPairingAndNewNullSpaces.getPairing().size(); costCharge = costCharge / size; costHbondDonnor = costHbondDonnor / size; costHbondAcceptor = costHbondAcceptor / size; costDehydron = costDehydron / size; costHydrophobicity = costHydrophobicity / size; costAromaticRing = costAromaticRing / size; costProbabilityDiff = costProbabilityDiff / size; double costOnPairs = algoParameters.getWEIGHT_DIFFERENCE_IN_CHARGES_BETWEEN_PAIRED_POINTS() * costCharge + algoParameters.getWEIGHT_DIFFERENCE_IN_HYDROPHOBICITY_BETWEEN_PAIRED_POINTS() * costHydrophobicity + algoParameters.getWEIGHT_HBOND_DONNOR() * costHbondDonnor + algoParameters.getWEIGHT_HBOND_ACCEPTOR() * costHbondAcceptor + algoParameters.getWEIGHT_DEHYDRON() * costDehydron + algoParameters.getWEIGHT_DIFFERENCE_AROMATICRING() * costAromaticRing + algoParameters.getWEIGHT_DIFFERENCE_IN_PROBABILITIES_IN_PAIRED_POINTS() * costProbabilityDiff; //double costOnUnpairedPoints = computeRatioFromUnpairedPointsHitToAllPointsHits(currentNewPairingAndNewNullSpaces, hitShape); //double newFinalCost = costOnPairs + algoParameters.getWEIGHT_UNPAIRED_POINT_IN_SMALLEST_MAP() * costOnUnpairedPoints; double sumWeight = algoParameters.getWEIGHT_DIFFERENCE_IN_CHARGES_BETWEEN_PAIRED_POINTS() + algoParameters.getWEIGHT_DIFFERENCE_IN_HYDROPHOBICITY_BETWEEN_PAIRED_POINTS() + algoParameters.getWEIGHT_HBOND_DONNOR() + algoParameters.getWEIGHT_HBOND_ACCEPTOR() + algoParameters.getWEIGHT_DEHYDRON() + algoParameters.getWEIGHT_DIFFERENCE_AROMATICRING() + algoParameters.getWEIGHT_DIFFERENCE_IN_PROBABILITIES_IN_PAIRED_POINTS(); double finalCost = costOnPairs / sumWeight; ResultFromScorePairing resultFromScorePairing = new ResultFromScorePairing(finalCost, rotationMatrixToRotateShape2ToShape1, translationVectorToTranslateShape2ToShape1, translationVectorToTranslateShape2ToOrigin, distanceResidual); return resultFromScorePairing; }
From source file:shapeCompare.PairingTools.java
public static RealVector alignPointFromShape2toShape1(RealVector trans2toOrigin, RealVector trans, RealMatrix rot, RealVector point) { RealVector translatedToOriginPoint = point.add(trans2toOrigin.copy()); RealVector rotatedPoint = rot.operate(translatedToOriginPoint); RealVector translatedBackPoint = rotatedPoint.subtract(trans2toOrigin); RealVector translatedToShape1 = translatedBackPoint.add(trans); return translatedToShape1; }
From source file:universal.Calc.java
private void Lines(int p0init, int p1init, int check) { double[] d = new double[6]; d[0] = paU[p0init].doubleValue();/*from w w w . j a v a 2 s .co m*/ d[1] = paV[p0init].doubleValue(); d[2] = paW[p0init].doubleValue(); d[3] = paX[p0init].doubleValue(); d[4] = paY[p0init].doubleValue(); d[5] = paZ[p0init].doubleValue(); RealVector p0 = new ArrayRealVector(d); d[0] = paU[p1init].doubleValue(); d[1] = paV[p1init].doubleValue(); d[2] = paW[p1init].doubleValue(); d[3] = paX[p1init].doubleValue(); d[4] = paY[p1init].doubleValue(); d[5] = paZ[p1init].doubleValue(); RealVector p1 = new ArrayRealVector(d); RealVector v = p0.subtract(p1); System.out.print("\n"); System.out.println(p0.toString()); System.out.println(p1.toString()); System.out.println(v.toString()); d[0] = paU[check].doubleValue(); d[1] = paV[check].doubleValue(); d[2] = paW[check].doubleValue(); d[3] = paX[check].doubleValue(); d[4] = paY[check].doubleValue(); d[5] = paZ[check].doubleValue(); RealVector p3 = new ArrayRealVector(d); RealVector v2 = p0.subtract(p3); Divisible(v, v2); }