double data[][] = new double[][]{ { 90, 60, 90 }, { 90, 90, 30 }, { 60, 60, 60 } }; SimpleMatrix m = new SimpleMatrix(data); SimpleMatrix inverted = m.invert(); System.out.println(inverted);
@Override public long process(BenchmarkMatrix[] inputs, BenchmarkMatrix[] outputs, long numTrials) { SimpleMatrix matA = inputs[0].getOriginal(); SimpleMatrix result = null; long prev = System.nanoTime(); for( long i = 0; i < numTrials; i++ ) { result = matA.invert(); } long elapsedTime = System.nanoTime()-prev; if( outputs != null ) { outputs[0] = new EjmlSimpleBenchmarkMatrix(result); } return elapsedTime; } }
public ArrayList<Double> mahalanobis(SimpleMatrix x, ArrayList<SimpleMatrix> means, ArrayList<SimpleMatrix> covs) { ArrayList<Double> mahalanobisDistances = new java.util.ArrayList<Double>(); for (int i = 0; i < means.size(); i++) { SimpleMatrix m = means.get(i); SimpleMatrix c = covs.get(i); double distance = x.minus(m).transpose().mult(c.invert()).mult(x.minus(m)).trace(); mahalanobisDistances.add(distance); } return mahalanobisDistances; }
private static void transformMeshFactory(MeshFactory meshFactory, SimpleMatrix transformationMatrix) { MeshFactory mesh = meshFactory; SimpleMatrix normalMatrix = transformationMatrix.invert().transpose(); Set<Vector3d> procesed = new HashSet<Vector3d>(); List<Point3d> vertices = new ArrayList<Point3d>(); for (int i = 0; i < mesh.vertices.size(); i++) { Point3d p = mesh.vertices.get(i); vertices.add(TransformationMatrix3d.transform(p, transformationMatrix)); } mesh.vertices = vertices; List<Vector3d> normals = new ArrayList<Vector3d>(); for (int i = 0; i < mesh.normals.size(); i++) { Vector3d v = mesh.normals.get(i); // if (procesed.contains(v)) { // continue; // } procesed.add(v); v = TransformationMatrix3d.transform(v, normalMatrix); // XXX !!!; v.normalize(); normals.add(v); } mesh.normals = normals; }
/** * Calculcates Mahalanobis distance between given point x and all given components defined by their means and covariances. * * @param x The reference point. * @param means The component means. * @param covs The component covariances. * @return A list with Mahalanobis distances between x and the given components. */ private static ArrayList<Double> mahalanobis(SimpleMatrix x, List<SimpleMatrix> means, List<SimpleMatrix> covs) { ArrayList<Double> mahalanobisDistances = new java.util.ArrayList<Double>(); for (int i = 0; i < means.size(); i++) { SimpleMatrix m = means.get(i); SimpleMatrix c = covs.get(i); // calculate Mahalanobis distance double distance = x.minus(m).transpose().mult(c.invert()).mult(x.minus(m)).trace(); mahalanobisDistances.add(distance); } return mahalanobisDistances; } }
/** * @see de.tuhh.luethke.okde.model.BaseSampleDistribution#evaluate(SimpleMatrix pointVector) */ @Override public double evaluate(SimpleMatrix pointVector) { SimpleMatrix smoothedCov = mGlobalCovariance.plus(mBandwidthMatrix); double d = 0d; double n = mGlobalMean.numRows(); double a = Math.pow(Math.sqrt(2 * Math.PI), n); double tmp = (-0.5d) * pointVector.minus(mGlobalMean).transpose().mult(smoothedCov.invert()).mult(pointVector.minus(mGlobalMean)).trace(); d += ((1 / (a * Math.sqrt(smoothedCov.determinant()))) * Math.exp(tmp)) * mGlobalWeight; return d; }
@Override public double evaluate(SimpleMatrix pointVector) { SimpleMatrix[] means = this.getSubMeans(); SimpleMatrix[] covs = this.getSubCovariances(); Double[] weights = this.getSubWeights(); double d = 0d; double n = means[0].numRows(); double a = Math.pow(Math.sqrt(2 * Math.PI), n); for (int i = 0; i < means.length; i++) { SimpleMatrix m = means[i]; SimpleMatrix c = covs[i].plus(this.mBandwidthMatrix); double w = weights[i]; double tmp = (-0.5d) * pointVector.minus(m).transpose().mult(c.invert()).mult(pointVector.minus(m)).trace(); d += ((1 / (a * Math.sqrt(c.determinant()))) * Math.exp(tmp)) * w; } return d; }
void updateDops( SimpleMatrix A ){ // Compute covariance matrix from A matrix [ECEF reference system] SimpleMatrix covXYZ = A.transpose().mult(A).invert().extractMatrix(0, 3, 0, 3); // Allocate and build rotation matrix SimpleMatrix R = Coordinates.rotationMatrix(rover); /** Covariance matrix obtained from matrix A (satellite geometry) [local coordinates] */ // Propagate covariance from global system to local system SimpleMatrix covENU = R.mult(covXYZ).mult(R.transpose()); //Compute DOP values rover.pDop = Math.sqrt(covXYZ.get(0, 0) + covXYZ.get(1, 1) + covXYZ.get(2, 2)); rover.hDop = Math.sqrt(covENU.get(0, 0) + covENU.get(1, 1)); rover.vDop = Math.sqrt(covENU.get(2, 2)); } }
SimpleMatrix invC = c.invert(); SimpleMatrix m = means.get(i); int lenM1 = m.numRows()-lenCond; m1.set(j,0,m.get(j+lenCond,0)); SimpleMatrix invNewC1 = newC1.invert(); double mahalanobisDistance = condition.minus(m2).transpose().mult(newC22.invert()).mult(condition.minus(m2)).trace(); double newWeight = ((1 / (a * Math.sqrt(newC22.determinant()))) * Math.exp((-0.5d) * mahalanobisDistance))* weights.get(i); conditionalWeights.add(newWeight);
/** * Undoes normalization for a homography matrix. */ protected void undoNormalizationH(DenseMatrix64F M, DenseMatrix64F N1, DenseMatrix64F N2) { SimpleMatrix a = SimpleMatrix.wrap(M); SimpleMatrix b = SimpleMatrix.wrap(N1); SimpleMatrix c = SimpleMatrix.wrap(N2); SimpleMatrix result = c.invert().mult(a).mult(b); M.set(result.getMatrix()); }
mu2 = means[i2]; w2 = weights[i2]; SimpleMatrix A = s1.plus(s2).invert(); dm = mu1.minus(mu2);
public void update(DenseMatrix64F yDense) { // a fast way to make the matrices usable by SimpleMatrix SimpleMatrix y = SimpleMatrix.wrap(yDense); // z = y - H x SimpleMatrix z = y.minus(H.mult(x)); // S = H P H' + R SimpleMatrix S = H.mult(P).mult(H.transpose()).plus(R); // K = PH'S^(-1) SimpleMatrix K = P.mult(H.transpose().mult(S.invert())); // x = x + Kz x = x.plus(K.mult(z)); // P = (I-kH)P = P - KHP P = P.minus(K.mult(H).mult(P)); }
public void update(DenseMatrix64F yDense) { // a fast way to make the matrices usable by SimpleMatrix SimpleMatrix y = SimpleMatrix.wrap(yDense); // z = y - H x SimpleMatrix z = y.minus(H.mult(x)); // S = H P H' + R SimpleMatrix S = H.mult(P).mult(H.transpose()).plus(R); // K = PH'S^(-1) SimpleMatrix K = P.mult(H.transpose().mult(S.invert())); // x = x + Kz x = x.plus(K.mult(z)); // P = (I-kH)P = P - KHP P = P.minus(K.mult(H).mult(P)); }
/** * Internal function which applies the rectification adjustment to a calibrated stereo pair */ private static void adjustCalibrated(DMatrixRMaj rectifyLeft, DMatrixRMaj rectifyRight, DMatrixRMaj rectifyK, RectangleLength2D_F64 bound, double scale) { // translation double deltaX = -bound.x0*scale; double deltaY = -bound.y0*scale; // adjustment matrix SimpleMatrix A = new SimpleMatrix(3,3,true,new double[]{scale,0,deltaX,0,scale,deltaY,0,0,1}); SimpleMatrix rL = SimpleMatrix.wrap(rectifyLeft); SimpleMatrix rR = SimpleMatrix.wrap(rectifyRight); SimpleMatrix K = SimpleMatrix.wrap(rectifyK); // remove previous calibration matrix SimpleMatrix K_inv = K.invert(); rL = K_inv.mult(rL); rR = K_inv.mult(rR); // compute new calibration matrix and apply it K = A.mult(K); rectifyK.set(K.getDDRM()); rectifyLeft.set(K.mult(rL).getDDRM()); rectifyRight.set(K.mult(rR).getDDRM()); }
/** * Internal function which applies the rectification adjustment to a calibrated stereo pair */ private static void adjustCalibrated(DenseMatrix64F rectifyLeft, DenseMatrix64F rectifyRight, DenseMatrix64F rectifyK, RectangleLength2D_F32 bound, double scale) { // translation double deltaX = -bound.x0*scale; double deltaY = -bound.y0*scale; // adjustment matrix SimpleMatrix A = new SimpleMatrix(3,3,true,scale,0,deltaX,0,scale,deltaY,0,0,1); SimpleMatrix rL = SimpleMatrix.wrap(rectifyLeft); SimpleMatrix rR = SimpleMatrix.wrap(rectifyRight); SimpleMatrix K = SimpleMatrix.wrap(rectifyK); // remove previous calibration matrix SimpleMatrix K_inv = K.invert(); rL = K_inv.mult(rL); rR = K_inv.mult(rR); // compute new calibration matrix and apply it K = A.mult(K); rectifyK.set(K.getMatrix()); rectifyLeft.set(K.mult(rL).getMatrix()); rectifyRight.set(K.mult(rR).getMatrix()); }
/** * Internal function which applies the rectification adjustment to a calibrated stereo pair */ private static void adjustCalibrated(FMatrixRMaj rectifyLeft, FMatrixRMaj rectifyRight, FMatrixRMaj rectifyK, RectangleLength2D_F32 bound, float scale) { // translation float deltaX = -bound.x0*scale; float deltaY = -bound.y0*scale; // adjustment matrix SimpleMatrix A = new SimpleMatrix(3,3,true,new float[]{scale,0,deltaX,0,scale,deltaY,0,0,1}); SimpleMatrix rL = SimpleMatrix.wrap(rectifyLeft); SimpleMatrix rR = SimpleMatrix.wrap(rectifyRight); SimpleMatrix K = SimpleMatrix.wrap(rectifyK); // remove previous calibration matrix SimpleMatrix K_inv = K.invert(); rL = K_inv.mult(rL); rR = K_inv.mult(rR); // compute new calibration matrix and apply it K = A.mult(K); rectifyK.set(K.getFDRM()); rectifyLeft.set(K.mult(rL).getFDRM()); rectifyRight.set(K.mult(rR).getFDRM()); }
DenseMatrix64F x = (new SimpleMatrix(H)).invert().mult(new SimpleMatrix(f)).getMatrix(); Vector3D result = new Vector3D(x.get(0), x.get(1), x.get(2));