精华内容
下载资源
问答
  • Java与Python计算特征向量的区别
    2021-03-16 02:38:12

    在apachecommons math3中,EigenDecomposition接受非对称矩阵,但它使用RealVector和{}类返回结果。为了得到实际的复杂结果,您必须将适当的实际结果组合成复共轭对。在

    在特征向量的情况下,你得到:eigenvector[0] = {-0.8660254038; 0}

    eigenvector[1] = {0.5; 1}

    这两个向量都与复共轭特征值对getRealEigenvalue(0) + getImagEigenvalue(0)*i和{}相关联,但这些向量不是实际的特征向量。实际的特征向量是复共轭对

    eigenvector[0] + eigenvector[1]*i和{}。在

    这些向量仍然不能“匹配”numpy返回的结果,但这是因为这两个库没有使用相同的规范化。特征向量不是唯一的;特征向量乘以任何非零标量(包括复数标量)仍然是特征向量。Java结果和numpy结果之间的唯一区别是标量乘数。在

    为了方便起见,我将浮点值转换为它们的精确值。也就是说,-0.8660254038是-sqrt(3)/2的浮点近似值。Java数学库给出了以下特征向量:

    ^{pr2}$

    如果你把第一个特征向量乘以-(sqrt(2)/2)*i,第二个特征向量乘以(sqrt(2)/2)*i,你就会得到以numpy返回的特征向量。在

    这是一个ipython会议的计算。v1和{}是上面显示的向量。在In [20]: v1 = np.array([-np.sqrt(3)/2 + 0.5j, 1j])

    In [21]: v1

    Out[21]: array([-0.8660254+0.5j, 0.0000000+1.j ])

    In [22]: v2 = np.array([-np.sqrt(3)/2 - 0.5j, -1j])

    In [23]: v2

    Out[23]: array([-0.8660254-0.5j, 0.0000000-1.j ])

    将v1乘以-(sqrt(2)/2)*i得到numpy.linalg.eig返回的第一个特征向量:In [24]: v1*(-np.sqrt(2)/2*1j)

    Out[24]: array([ 0.35355339+0.61237244j, 0.70710678-0.j ])

    将v2乘以(sqrt(2)/2)*i得到numpy.linalg.eig返回的第二个特征向量:In [25]: v2*(np.sqrt(2)/2*1j)

    Out[25]: array([ 0.35355339-0.61237244j, 0.70710678+0.j ])

    为了方便起见,这里重复了numpy计算。evecs的列是特征向量。在In [28]: evals, evecs = np.linalg.eig(a)

    In [29]: evecs

    Out[29]:

    array([[ 0.35355339+0.61237244j, 0.35355339-0.61237244j],

    [ 0.70710678+0.j , 0.70710678-0.j ]])

    更多相关内容
  • 利用第三方矩阵计算工具包JAMA,求特征值、特征向量 API: http://math.nist.gov/javanumerics/jama/doc/Jama/Matrix.html 应用: 1.JAMA包的导入 1)https://mvnrepository.com/ 2)搜索JAMA,选第一个:gov....
  • 特征值与特征向量定义 Ax =λx,则λ是A的一个特征值,x为A对应于特征值λ的特征向量 特征值为零,矩阵不可逆 求A的特征值:解特征多项式det(A-λI) eigen求矩阵的特征值与特征向量,但有限制,必须是对称矩阵 #include ...
  • AHP层次分析法计算权重、特征值、特征向量,第一作者刘兴,其他地方下载需要47个币 【 尚有疑问,欢迎沟通!! 1.CSDN上有人说可用; 2.亲自试验,代码流畅,但个人感觉特征值、特征向量存疑; 3.用java求出的特征...
  • java求矩阵的特征值和特征向量

    热门讨论 2012-05-25 11:18:29
    这几天做一个项目,需要用到 求矩阵的特征值特征向量。我c++学的不好,所以就去网站找了很多java的源代码,来实现这个功能。很多都不完善,甚至是不准确。所以自己参考写了一个。这个用于我一个朋友的毕业设计。结果...
  • java求矩阵的特征值和特征向量源码
  • 特征值特征向量java源码dANN 2.x dANN 是一个人工智能和人工遗传学库,旨在采用传统算法并作为研究和开发新算法的平台。 随着新算法的开发和证明是有效的,它们将被集成到核心库中。 它目前是用 Java 编写的,并且...
  • 矩阵求特征值特征向量Java代码1.代码介绍2.参考文章 1.代码介绍   代码中实现的模块如下: 矩阵转置 点乘 自动索引生成 矩阵复制 获取给定索引矩阵所在行 矩阵行列式 矩阵正交化 矩阵求逆 矩阵QR分解(注:QR分解...

    矩阵求特征值特征向量Java代码

    1.代码介绍

      代码中实现的模块如下:

    1. 矩阵转置
    2. 点乘
    3. 自动索引生成
    4. 矩阵复制
    5. 获取给定索引矩阵所在行
    6. 矩阵行列式
    7. 矩阵正交化
    8. 矩阵求逆
    9. 矩阵QR分解(注:QR分解函数只返回一个矩阵,设输入矩阵为m×n,则前m行为Q矩阵,后n行为R矩阵)
    10. 矩阵乘法
    11. 矩阵相减
    12. 求特征值(注:返回值为二维矩阵,对角线上的方为特征值)
    13. 求特征向量

      所有代码如下:
    注意:本文中代码所在包为util,类名为Eig,使用时注意对于及修改;代码传入参数等也请注意阅读函数说明。

    package util;
    
    import java.util.Arrays;
    
    /**
     * @(#)Eig.java The class of Eig.
     * @author: 因吉
     * @Email: inki.yinji@qq.com
     * @Created: November 23, 2019.
     * @Last_modified: November 23, 2019.
     */
    public class Eig {
    
    	/**
    	 ************
    	 * Array transpose.
    	 * 
    	 * @param paraArray The transposing array(double[][]).
    	 * 
    	 * @return returnArray The transposed array(double[][]).
    	 ************
    	 */
    	public static double[][] arrayTranspose(double[][] paraArray) {
    		int tempM = paraArray.length;
    		int tempN = paraArray[0].length;
    		double[][] returnArray = new double[tempN][tempM];
    		for (int i = 0; i < tempM; i++) {
    			for (int j = 0; j < tempN; j++) {
    				returnArray[j][i] = paraArray[i][j];
    			} // Of for j
    		} // Of for i
    
    		return returnArray;
    	}// Of arrayTranspose
    	
    	/**
    	 ************
    	 * Array corresponding elements multiply and add all elements.点积
    	 * 
    	 * @param paraFirstArray  The first array(double[]).
    	 * @param paraSecondArray The second array(double[]).
    	 * @return The result(double).
    	 ************
    	 */
    	public static double arrayMultiplyAndAdd(double[] paraFirstArray, double[] paraSecondArray) {
    		int tempM = paraFirstArray.length;
    		double resultMultipliedArray = 0;
    
    		for (int i = 0; i < tempM; i++) {
    			resultMultipliedArray += paraFirstArray[i] * paraSecondArray[i];
    		} // Of for i
    
    		return resultMultipliedArray;
    	}// Of arrayMultiplyAndAdd
    	
    	/**
    	 ************
    	 * Get the index of array.
    	 * 
    	 * @param paraLen The length of array(int).
    	 * @return The index of array(int[]).
    	 ************
    	 */
    	public static int[] arrayIndexAuto(int paraLen) {
    		int[] returnArray = new int[paraLen];
    		for (int i = 0; i < paraLen; i++) {
    			returnArray[i] = i;
    		}
    		return returnArray;
    	}// Of arrayIndexAuto
    
    	/**
    	 ************
    	 * Get the index of array.
    	 * 
    	 * @param paraStrat The start index(int).
    	 * @param paraEnd   The end index(int).
    	 * @return The index of array(int[]).
    	 ************
    	 */
    	public static int[] arrayIndexAuto(int paraStrat, int paraEnd) {
    		int[] returnArray = new int[paraEnd - paraStrat];
    		for (int i = 0; i < returnArray.length; i++) {
    			returnArray[i] = i + paraStrat;
    		}
    		return returnArray;
    	}// Of arrayIndexAuto
    	
    	/**
    	 ************
    	 * Copy array.
    	 * 
    	 * @param paraArray The array(double[][]).
    	 * @return The copied array(double[][]).
    	 ************
    	 */
    	public static double[][] arrayCopy(double[][] paraArray) {
    		int tempM = paraArray.length;
    		double[][] resultArray = new double[tempM][];
    		for (int i = 0; i < tempM; i++) {
    			resultArray[i] = paraArray[i];
    		} // Of for i
    		return resultArray;
    	}// Of arrayCopy
    	
    	/**
    	 ************
    	 * Get the elements of the corresponding row of the incoming array.
    	 * 
    	 * @param paraArray The import array(double[][]).
    	 * @param paraIndex The index i(int[]).
    	 * @return The row elements corresponding incoming array(doubel[][]).
    	 ************
    	 */
    	public static double[][] arrayRowValue(double[][] paraArray, int[] paraIndex) {
    		int tempParaIndex = paraIndex.length;
    		double[][] returnRowValue = new double[tempParaIndex][];
    
    		for (int i = 0; i < returnRowValue.length; i++) {
    			returnRowValue[i] = paraArray[paraIndex[i]];
    		} // Of for i
    
    		return returnRowValue;
    	}// Of arrayRowValue
    	
    	/**
    	 ************
    	 * The determinant of matrix.求解矩阵行列式
    	 * 
    	 * @param paraMatrix The given matrix(double[][]).
    	 * 
    	 * @return The answer of determinant.
    	 ************
    	 */
    	public static double matrixDeterminant(double[][] paraMatrix) {
    		int tempM = paraMatrix.length;
    		int tempN = paraMatrix[0].length;
    
    		if (tempM == 1) {
    			return paraMatrix[0][0];
    		} else if (tempM == 2) {
    			return paraMatrix[0][0] * paraMatrix[1][1] - paraMatrix[1][0] * paraMatrix[0][1];
    		} // Of if
    
    		double resultValue = 0;
    		int k;
    		for (int i = 0; i < tempN; i++) {
    			double[][] tempMatrix = new double[tempM - 1][tempN - 1];
    			for (int j = 0; j < tempM - 1; j++) {
    				k = 0;
    				while (k < tempN - 1) {
    					if (k < i) {
    						tempMatrix[j][k] = paraMatrix[j + 1][k];
    					} else {
    						tempMatrix[j][k] = paraMatrix[j + 1][k + 1];
    					} // Of if
    					k++;
    				} // Of while
    			} // Of for j
    			resultValue += (Math.pow(-1., i)) * paraMatrix[0][i] * matrixDeterminant(tempMatrix);
    		} // Of for i
    
    		return resultValue;
    	}// Of matrixDeterminant
    
    	/**
    	 ************
    	 * The gram schimidt of matrix.求解矩阵正交化
    	 * 
    	 * @param paraMatrix The given matrix(double[][]).
    	 * 
    	 * @return The gram schimidt of matrix.
    	 ************
    	 */
    	public static double[][] matrixGramSchimidt(double[][] paraMatrix) {
    		if (paraMatrix == null) {
    			return null;
    		} // Of if
    
    		double[][] tempTransposedMatrix = arrayTranspose(paraMatrix);
    		int tempM = tempTransposedMatrix.length;
    		int tempN = tempTransposedMatrix[0].length;
    
    		double[][] resultMatrix = new double[tempM][tempN];
    		double tempValue = 0;
    		double tempFactor = 0;
    		for (int i = 0; i < tempM; i++) {
    			for (int j = 0; j < tempN; j++) {
    				tempValue = tempTransposedMatrix[i][j];
    				for (int k = 0; k < i; k++) {
    					tempFactor = (1. * arrayMultiplyAndAdd(tempTransposedMatrix[i], resultMatrix[k]))
    							/ arrayMultiplyAndAdd(resultMatrix[k], resultMatrix[k]);
    					tempValue -= tempFactor * resultMatrix[k][j];
    				} // Of for k
    				resultMatrix[i][j] = tempValue;
    			} // Of for j
    		} // Of for i
    
    		return arrayTranspose(resultMatrix);
    	}// Of matrixGramSchimidt
    
    	/**
    	 ************
    	 * The inverse of matrix.矩阵求逆
    	 * 
    	 * @param paraMatrix The given matrix(double[][]).
    	 * 
    	 * @return The inverse of matrix(double[][]).
    	 ************
    	 */
    	public static double[][] matrixInverse(double[][] paraMatrix) {
    		if (paraMatrix == null) {
    			return null;
    		} // Of if
    
    		// Make sure that this matrix is invertible.
    		if (matrixDeterminant(paraMatrix) == 0) {
    			System.out.println("Fetal error, the matrix can not be invertible.");
    			System.exit(0);
    		} // Of if
    
    		int tempM = paraMatrix.length;
    		int tempN = paraMatrix[0].length * 2;
    
    		double[][] tempCopyMatrix = new double[tempM][tempN];
    
    		for (int i = 0; i < tempM; i++) {
    			for (int j = 0; j < tempN; j++) {
    				if (j < tempM) {
    					tempCopyMatrix[i][j] = paraMatrix[i][j];
    				} else {
    					if (j == i + tempM) {
    						tempCopyMatrix[i][j] = 1;
    					} // Of if
    				} // Of if
    			} // Of for j
    		} // Of for i
    
    		double tempTimes = 0;
    		for (int i = 0; i < tempM; i++) {
    			if (tempCopyMatrix[i][i] == 0) {
    				int j;
    				for (j = i + 1; j < tempM; j++) {
    					if (tempCopyMatrix[j][i] != 0) {
    						break;
    					} // Of if
    				} // Of for j
    
    				if (j != i + 1) {
    					for (int k = 0; k < tempN; k++) {
    						double temppVlaue = tempCopyMatrix[i][k];
    						tempCopyMatrix[i][k] = tempCopyMatrix[j][k];
    						tempCopyMatrix[j][k] = temppVlaue;
    					} // Of for k
    				} // Of if
    			} // Of if
    
    			for (int j = i + 1; j < tempM; j++) {
    				if (tempCopyMatrix[j][i] != 0) {
    					tempTimes = (tempCopyMatrix[j][i]) / tempCopyMatrix[i][i];
    					for (int k = i; k < tempN; k++) {
    						tempCopyMatrix[j][k] /= tempTimes;
    						tempCopyMatrix[j][k] -= tempCopyMatrix[i][k];
    					} // Of for k
    				} // Of if
    			} // Of for j
    		} // Of for i
    
    		for (int i = 0; i < tempM; i++) {
    			for (int j = i + 1; j < tempN / 2.; j++) {
    				if (tempCopyMatrix[i][j] != 0) {
    					tempTimes = tempCopyMatrix[i][j] / tempCopyMatrix[j][j];
    					for (int k = j; k < tempN; k++) {
    						tempCopyMatrix[i][k] -= tempTimes * tempCopyMatrix[j][k];
    					} // Of for k
    				} // Of if
    			} // Of for j
    		} // Of for i
    
    		for (int i = 0; i < tempM; i++) {
    			tempTimes = tempCopyMatrix[i][i];
    			for (int j = 0; j < tempN; j++) {
    				tempCopyMatrix[i][j] /= tempTimes;
    			} // Of for j
    		} // Of for i
    
    		double[][] resultMatrix = new double[tempM][tempN / 2];
    		for (int i = 0; i < tempM; i++) {
    			for (int j = 0; j < tempN / 2; j++) {
    				resultMatrix[i][j] = tempCopyMatrix[i][j + tempN / 2];
    			} // Of for j
    		} // Of for i
    
    		return resultMatrix;
    	}// Of matrixInverse
    
    	/**
    	 ************
    	 * The QR-decomposition of matrix.矩阵QR分解
    	 * 
    	 * @param paraMatrix  The given matrix(double[][]).
    	 * @param paraMatrixQ The given matrix, the size echo paraMatrix(double[][]).
    	 ************
    	 */
    	public static double[][] matrixQrDecomposition(double[][] paraMatrix) {
    		double[][] tempOrthogonalMatrix = arrayTranspose(matrixGramSchimidt(paraMatrix));
    		int tempM = tempOrthogonalMatrix.length;
    		int tempN = tempOrthogonalMatrix[0].length;
    
    		double[][] tempMatrixQ = new double[tempM][tempN];
    		for (int i = 0; i < tempM; i++) {
    			double tempMag = magnitude(tempOrthogonalMatrix[i]);
    			for (int j = 0; j < tempN; j++) {
    				tempMatrixQ[i][j] = tempOrthogonalMatrix[i][j] / tempMag;
    			} // Of for j
    		} // Of for i
    
    		double[][] tempMatrixR = matrixMultiply(tempMatrixQ, paraMatrix);
    		double[][] resultSummary = new double[tempM + tempN][tempM];
    		for (int i = 0; i < tempN; i++) {
    			for (int j = 0; j < tempM; j++) {
    				resultSummary[i][j] = tempMatrixQ[j][i];
    			} // Of for j
    		} // Of for i
    
    		for (int i = tempN; i < resultSummary.length; i++) {
    			for (int j = 0; j < tempM; j++) {
    				resultSummary[i][j] = tempMatrixR[i - tempN][j];
    			} // Of for j
    		} // Of for i
    
    		return resultSummary;
    	}// Of matrixQrDecomposition
    
    	/**
    	 ************
    	 * The magnitude.
    	 * 
    	 * @param paraMatrix The given matrix(double[]).
    	 * @return The answer.
    	 ************
    	 */
    	private static double magnitude(double[] paraMatrix) {
    		return Math.sqrt(arrayMultiplyAndAdd(paraMatrix, paraMatrix));
    	}// Of magnitude
    
    	/**
    	 ************
    	 * The matrix multiply.
    	 * 
    	 * @param paraFirstMatrix  The given first matrix(double[][]).
    	 * @param paraSecondMatrix The given second matrix(double[][]).
    	 * @return The answer(double[][]).
    	 ************
    	 */
    	public static double[][] matrixMultiply(double[][] paraFirstMatrix, double[][] paraSecondMatrix) {
    		if (paraFirstMatrix == null || paraSecondMatrix == null) {
    			return null;
    		} // Of if
    
    		if (paraFirstMatrix[0].length != paraSecondMatrix.length) {
    			System.out.println("Fetal error: The size of two inputed matrix is illegally.");
    			System.exit(0);
    		} // Of if
    
    		int tempMa = paraFirstMatrix.length;
    		int tempNa = paraFirstMatrix[0].length;
    		int tempNb = paraSecondMatrix[0].length;
    
    		double[][] resultMatrix = new double[tempMa][tempNb];
    		for (int i = 0; i < tempMa; i++) {
    			for (int j = 0; j < tempNb; j++) {
    				double tempSum = 0;
    				for (int k = 0; k < tempNa; k++) {
    					tempSum += paraFirstMatrix[i][k] * paraSecondMatrix[k][j];
    				} // Of for k
    				resultMatrix[i][j] = tempSum;
    			} // Of for j
    		} // Of for i
    		return resultMatrix;
    	}// Of matrixMultiply
    
    	/**
    	 ************
    	 * The eig of matrix.
    	 * 
    	 * @param paraMatrix The given matrix(double[][]).
    	 * @param paraIter   The maximum iteration.
    	 * @return The eig of matrix.
    	 ************
    	 */
    	public static double[][] matrixEigValue(double[][] paraMatrix, int paraIter) {
    		int tempM = paraMatrix.length;
    		int tempN = paraMatrix[0].length;
    		int[] tempIndexQ = arrayIndexAuto(tempM);
    		int[] tempIndexR = arrayIndexAuto(tempM, tempM + tempN);
    		for (int i = 0; i < paraIter; i++) {
    			double[][] tempSummary = matrixQrDecomposition(paraMatrix);
    			double[][] tempMatrixQ = arrayRowValue(tempSummary, tempIndexQ);
    			double[][] tempMatrixR = arrayRowValue(tempSummary, tempIndexR);
    			paraMatrix = matrixMultiply(tempMatrixR, tempMatrixQ);
    		} // Of for i
    
    		return paraMatrix;
    	}// Of matrixEigValue
    	
    	/**
    	 ************
    	 * The eig vector of matrix.求矩阵特征向量
    	 * 
    	 * @param paraMatrix The given matrix(double[][]).
    	 * @param paraIter   The maximum iteration.
    	 * @return The eig vector of matrix.
    	 ************
    	 */
    	public static double[][] matrixEigVector(double[][] paraMatrix, int paraIter) {
    		int tempM = paraMatrix.length;
    		int tempN = paraMatrix[0].length;
    		double[][] tempMatrix = matrixEigValue(arrayCopy(paraMatrix), paraIter);
    		for (int i = 0; i < tempM; i++) {
    			for (int j = 0; j < tempN; j++) {
    				if (i != j) {
    					tempMatrix[i][j] = 0;
    				}//Of if
    			}//Of for j
    		}//Of for i
    		
    		return matrixInverse(matrixSubtract(paraMatrix, tempMatrix));
    	}//Of matrixEigVector
    
    	/**
    	 ************
    	 * The subtract of matrix.求矩阵相减
    	 * 
    	 * @param paraFirstMatrix The first given matrix(double[][]).
    	 * @param paraFirstMatrix The second given matrix(double[][]).
    	 * @return The subtract of two matrix.
    	 ************
    	 */
    	public static double[][] matrixSubtract(double[][] paraFirstMatrix, double[][] paraSecondMatrix) {
    		if (paraFirstMatrix == null || paraSecondMatrix == null) {
    			return null;
    		}//Of if
    		
    		int tempMFirst = paraFirstMatrix.length;
    		int tempNFirst = paraFirstMatrix[0].length;
    		int tempMSecond = paraSecondMatrix.length;
    		int tempNSecond = paraSecondMatrix[0].length;
    		
    		if (tempMFirst != tempMSecond || tempNFirst != tempNSecond) {
    			System.out.println("Fetal error, the inputed matrix is illegal in matrixSub(double[][], double[][])");
    			System.exit(0);
    		}//Of if
    		
    		double[][] resultMatrix = new double[tempMFirst][tempNFirst];
    		for (int i = 0; i < tempMFirst; i++) {
    			for (int j = 0; j < tempNFirst; j++) {
    				resultMatrix[i][j] = paraFirstMatrix[i][j] - paraSecondMatrix[i][j];
    			}//Of for j
    		}//Of for i
    		
    		return resultMatrix;
    	}//Of matrixSubtract
    	
    	/**
    	 ************
    	 * The main
    	 ************
    	 */
    	public static void main(String[] args) {
    //		double[][] tempData = { { 1, 0, 0 }, { 1, 1, 0 }, { 1, 1, 1 } };
    		double[][] tempData = {{2,1}, {1,2}};
    		double[][] tempEigValue = matrixEigValue(tempData, 1000);
    		double[][] tempEigVector = matrixEigVector(tempData, 1000);
    		System.out.println("The eig value is: " + Arrays.deepToString(tempEigValue));
    		System.out.println("The eig vector is: " +Arrays.deepToString(tempEigVector));
    	}// Of main
    }//Of Eig
    

    2.参考文章

    1. QR算法讲解
    2. 矩阵求逆、正交化等
    展开全文
  • 特征值特征向量 java源码 关于 虹软人脸识别SDK之Java版,支持SDK 1.1+,以及当前最新版本2.0,滴滴,抓紧上车! 前言 由于业务需求,最近跟人脸识别杠上了,本以为虹软提供的SDK是那种面向开发语言的,结果是一堆...
  • java语言编写的一个求特征值和特征向量,算法是:先采用正交分解进行QR分解,然后进行迭代N次后求出对角矩阵和正交矩阵,对角矩阵即为特征值,正交矩阵即为特征向量
  • 在Apache Commons Math 3中,EigenDecomposition接受非对称矩阵,但它使用RealVector和RealMatrix类返回结果.要获得实际的复杂结果,您必须将适当的实际结果组合成复杂的共轭对.... 1}这两个向量都与复合共轭特征...

    在Apache Commons Math 3中,EigenDecomposition接受非对称矩阵,但它使用RealVector和RealMatrix类返回结果.要获得实际的复杂结果,您必须将适当的实际结果组合成复杂的共轭对.

    在特征向量的情况下,您得到:

    eigenvector[0] = {-0.8660254038; 0}

    eigenvector[1] = {0.5; 1}

    这两个向量都与复合共轭特征值对相关联getRealEigenvalue(0)getImagEigenvalue(0)* i和getRealEigenvalue(1)getImagEigenvalue(1)* i,但这些向量不是实际的特征向量.实际的特征向量是复共轭对

    特征向量[0]特征向量[1] * i和特征向量[0] – 特征向量[1] * i.

    那些向量仍然不匹配numpy返回的结果,但这是因为这两个库没有使用相同的规范化.特征向量不是唯一的;特征向量乘以任何非零标量(包括复数标量)仍然是特征向量. Java结果和numpy结果之间的唯一区别是标量乘数.

    为方便起见,我将浮点值转换为它们的确切值.也就是说,-0.8660254038是-sqrt(3)/ 2的浮点近似. Java数学库提供以下特征向量:

    [-sqrt(3)/2 + (1/2)*i] and [-sqrt(3)/2 - (1/2)*i]

    [ 0 + 1*i] [ 0 - 1*i]

    如果你将第一个特征向量乘以 – (sqrt(2)/ 2)* i和第二个乘以(sqrt(2)/ 2)* i,你将得到numpy返回的特征向量.

    这是一个带有该计算的ipython会话. v1和v2是上面显示的向量.

    In [20]: v1 = np.array([-np.sqrt(3)/2 + 0.5j, 1j])

    In [21]: v1

    Out[21]: array([-0.8660254+0.5j, 0.0000000+1.j ])

    In [22]: v2 = np.array([-np.sqrt(3)/2 - 0.5j, -1j])

    In [23]: v2

    Out[23]: array([-0.8660254-0.5j, 0.0000000-1.j ])

    将v1乘以 – (sqrt(2)/ 2)* i得到numpy.linalg.eig返回的第一个特征向量:

    In [24]: v1*(-np.sqrt(2)/2*1j)

    Out[24]: array([ 0.35355339+0.61237244j, 0.70710678-0.j ])

    将v2乘以(sqrt(2)/ 2)* i得到numpy.linalg.eig返回的第二个特征向量:

    In [25]: v2*(np.sqrt(2)/2*1j)

    Out[25]: array([ 0.35355339-0.61237244j, 0.70710678+0.j ])

    为方便起见,这里是numpy计算的重复. evecs列是特征向量.

    In [28]: evals, evecs = np.linalg.eig(a)

    In [29]: evecs

    Out[29]:

    array([[ 0.35355339+0.61237244j, 0.35355339-0.61237244j],

    [ 0.70710678+0.j , 0.70710678-0.j ]])

    展开全文
  • 特征值和特征向量方阵A的特征值和特征向量为标量λ和满足条件的非零向量vAv =λv在这个等式中, A是一个n×n矩阵, v是非零n×1向量,而λ是标量(可以是实数或复数)。该方程具有解的任何λ值都称为矩阵A的特征值。也...

    特征值和特征向量

    方阵A的特征值和特征向量为标量λ和满足条件的非零向量v

    Av =λv

    在这个等式中, A是一个n×n矩阵, v是非零n×1向量,而λ是标量(可以是实数或复数)。该方程具有解的任何λ值都称为矩阵A的特征值。也称为特征值。与此方程相对应的向量v被称为特征向量。特征值问题可以写成

    A · v -λ· v = 0

    A·v -λ· I · v = 0

    ( A-λ·I )· v = 0

    如果v为非零值,则该方程式仅具有以下解:

    | A -λ· I | = 0

    该方程被称为A的特征方程,并且是一个阶多项式在λ有n根。这些根称为A的特征值。我们将只处理n个不同根的情况;通过它们可以重复。对于每个特征值,将存在特征值方程式为真的特征向量。

    示例:查找2×2矩阵的特征值和特征向量

    matlab-eigenvalues-and-eigenvectors.png

    剩下的就是找到两个特征向量。让我们找到的特征向量,V 1,用特征值,λ1 = -1连接,第一。

    matlab-eigenvalues-and-eigenvectors2.png

    matlab-eigenvalues-and-eigenvectors3.png

    在这种情况下,我们发现第一个特征向量是任意两个分量列向量,其中两个项的大小相等且符号相反。

    matlab-eigenvalues-and-eigenvectors4.png

    其中k 1是一个任意常数。如果我们不必使用+1和-1,则可以使用任意两个大小相等且符号相反的量。

    对第二个特征值进行相同的处理:

    matlab-eigenvalues-and-eigenvectors5.png

    同样,特征向量的+1和-2的选择是任意的。只有它们的比例是必不可少的。这在下面的MATLAB代码中进行了演示。

    matlab-eigenvalues-and-eigenvectors6.png

    注意:MATLAB选择的特征向量方程式与我们选择的方程式不同。 v1,1与v1,2的比率以及v2,1与v2,2的比率与我们的解决方案相似;系统选择的特征向量不是唯一的,但它们的成分之比是唯一的。 MATLAB选择的值应使每个特征向量的成分平方和等于1。

    0

    相关文章:MATLAB教程 MATLAB教程 MATLAB是MathWorks开发的一种编程语言。它最初是一种矩阵编程语言,线性代数编程很简单。它既可以在交互式会话下运行,也可以作为批处理作业运行。本教程为您积极地介绍了MATLAB编程语言。它旨在让学生流利使用MATLAB编程语言。基于问题的MATLAB示例已经以简单易用的方式给出,以使您的学习快速而有效。 听众 本教程已为初学者准备,以帮助他们了解MATLAB的基础到高级功能。完成本教程后,您会发现自己在使用MATLAB方面具有中等水平的专业知识,从这里您可以进入更高的层次。 先决条件 我们假设您对任何计算机编程都有一点了解,并且了解变量,常量,表达式,语句等概念。如果您使用其他任何高级编程语言(例如C,C++或Java)进行编程,那么非常有益,学习MATLAB对您来说将很有趣。...

    MATLAB-数字 MATLAB-数字 MATLAB支持各种数字类,包括有符号和无符号整数以及单精度和双精度浮点数。默认情况下,MATLAB将所有数值存储为双精度浮点数。 您可以选择将任何数字或数字数组存储为整数或单精度数字。 所有数值类型都支持基本数组运算和数学运算。 转换为各种数值数据类型 MATLAB提供以下功能以转换为各种数值数据类型- Function Purpose double Converts...

    MATLAB-集成 MATLAB-整合 集成处理两种本质上不同的问题。 在第一种类型中,给出了函数的导数,我们想找到函数。因此,我们基本上扭转了分化的过程。这种逆过程称为反微分,或者找到原始函数,或者找到不定积分。 第二类问题包括相加大量非常小的数量,然后随着数量的大小接近零而取一个极限,而项的数量趋于无穷大。这个过程导致定积分的定义。 定积分用于查找面积,体积,重心,惯性矩,力完成的功以及许多其他应用。 使用MATLAB查找不定积分 根据定义,如果函数f(x)的导数是f’(x),那么我们说f’(x)相对于x的不定积分是f(x)。例如,由于x 2的导数(相对于x)为2x,因此可以说2x的不定积分为x 2 。...

    在MATLAB中使用变量和数组 在MATLAB中使用变量和数组 在任何MATLAB程序中,数据的结构单位都是数组。数组是记录值的集合,这些记录值被组织成行和列,并且以单个名称已知。数组可以分配为向量或矩阵。术语“向量”通常用于定义仅具有一维的数组,而术语“矩阵”通常用于确定具有二维或更多维的数组。 行号说明了数组的大小,数组中的列号以及行号首先提到了。数组中的项目总数将是行数和列数的乘积。 例如,以下数组的大小为: 数组中的各个项目都由数组名称寻址,后跟特定项目的行和列。如果数组是行向量或列向量,则仅需要一个下标。例如,在前面的数组中,a(2,1)为3,c(2)= 2。 MATLAB变量是包含数组的内存区域,由客户指定的名称调用。通过在适当的MATLAB命令中包含数组的名称,可以随时使用或修改数组的内容。 MATLAB变量名称必须以字母开头,然后是字母,数字和下划线(_)字符的任何序列。仅前63个字符为必填项;如果使用的字符数超过63,则其余字符将被忽略。如果两个变量的名称仅在第64个字符不同,则MATLAB会将它们视为相同的变量。 在MATLAB中创建和初始化变量 MATLAB变量在初始化时会自动生成。...

    与MATLAB兼容 适用于MATLAB中基本操作的兼容数组大小 兼容的数组大小意味着对于每个维度,输入数组的维度大小都是相同的,或者其中一个是标量。二进制运算符和函数在具有兼容大小的数组上可以很好地运行。 MATLAB会隐式扩展具有兼容大小的数组,以使它们在按元素操作或函数执行期间具有相同的大小。 具有兼容大小的数组输入 二维阵列输入 让我们了解具有兼容大小的标量,向量和矩阵的一些组合: 两个数组输入的大小完全相同。 一个数组输入是标量。 一个输入是矩阵,另一个输入是具有相似行数的列向量。 一个输入是列向量,另一个是行向量。...

    MATLAB 2D fill() MATLAB fill() 为了绘制填充的多边形,我们可以使用fill()函数。记录顶点以及要填充的颜色。 句法...

    MATLAB 3D mesh() MATLAB mesh() 网格可创建由X,Y和Z指定的线框参数化曲面,颜色由C指定。 句法...

    MATLAB rref MATLAB rref 精简行梯形形式(rref)通过对所有行进行缩放ERO,使对角线上的a ii系数全部变为1,从而使Gauss-Jordan消除方法更进一步。 简化的行梯形形式将这一步骤进一步推为全1,而不是a,因此b的列就是解决方案: MATLAB具有内置函数来执行此操作,称为rref 。例如,对于前面的示例:...

    展开全文
  • 在eclipse下,解决java与matlib转换麻烦的情况 java利用matlib导出的jar包计算特征值与特征向量,方便计算大数据情况下的PCA与谱聚类。
  • 包含QR分解法,其中有北航大作业三道题目完整版,程序运行无误,另外还收集到java版本。保质保量
  • 由所有的特征向量组成了特征空间 3、特征向量的应用 既然特征值表达了重要程度且和特征向量所对应,那么特征值大的就是主要信息了,基于这点我们就可以提取各种有价值的信息了。 关于找一找教程网 本站文章仅代表...
  • java求矩阵的特征值和特征向量(ahp层次分析法计算权重)(附源代码)》由会员分享,可在线阅读,更多相关《java求矩阵的特征值和特征向量(ahp层次分析法计算权重)(附源代码)(5页珍藏版)》请在金锄头文库上搜索。...
  • java求矩阵的特征值和特征向量(AHP层次分析法计算权重)(附源代码).pdf
  • 实现QR分解法求矩阵的所有特征值及特征向量-Java realization of QR decomposition for matrix eigenvalues and all eigenvectors
  • java版求矩阵特征值

    热门讨论 2009-04-01 22:10:04
    雅克比迭代式法求实对称矩阵的特征值特征向量
  • 第二节 方阵的特征值与特征向量

    千次阅读 2018-04-01 20:23:18
    特征值与特征向量:设A为n阶方阵,若数 和n维的非零列向量x,使关系式Ax=λx成立,则称数λ为方阵A的特征值,非零向量x称为A的对应与特征值 的特征向量。2 .特征多项式3 .特征方程 二 .原理,公式和法则1 .求...
  • 数据分析---SVD,特征值和特征向量

    千次阅读 2016-01-19 16:24:30
    特征值和特征向量其实是线性代数里面的东西,好久之前学习的,差不多都忘光了,这里还是再复习下,慢慢拣回来。网上其实也有很多各种介绍,从基本的原理到几何解释,理解起来还是要一定的数学功底,不过慢慢理解了就...
  • 在MATLAB中,计算矩阵A的特征值和特征向量的函数是eig(A),常用的调用格式有 5种:(1) E=eig(A):求矩阵A的全部特征值,构成向量E。 想求最大特征值用:max(eig(A))就好了。(2) [V,D]=eig(A):求矩阵A的全部特征值...
  • 特征向量中心性

    千次阅读 2021-08-23 16:28:52
    特征向量中心性的基本思想是,一个节点的中心性是相邻节点中心性的函数。也就是说,与你连接的人越重要,你也就越重要。 特征向量中心性和点度中心性不同,一个点度中心性高即拥有很多连接的节点,但特征向量中心性...
  • 我在使用matlabeig函数计算对称矩阵的特征值和特征向量时遇到了一个问题。在矩阵D是10x10所有对角线元素=0.45所有非对角线元素=-0.05当使用[vec,val]=eig(D)时,一些得到的特征向量包含复数(即0.3384+0.0052i)。我...
  • 特征值篇1——特征值和特征向量特征值篇1--特征值和特征向量_thompson的博客-CSDN博客​blog.csdn.net特征值篇2——特征子空间特征值篇2--特征子空间_thompson的博客-CSDN博客​blog.csdn.net特征值篇3——矩阵可...
  • 特征值与MATLAB给出的特征值相同,但是当我将特征向量与MATLAB给出的特征向量进行比较时,我发现了一些小的(小于1E-10)差异.为什么会这样,我怎样才能使两个结果相等?我试图提高NumPy的精度,但它没有用.import numpy ...
  • Java之矩阵求特征值

    千次阅读 2016-03-05 15:53:01
    public class MatrixEigenValue { public static int Hessenberg(double[][] Matrix,int n,double[][]ret) { int i; int j; int k; double temp; int MaxNu; n-=1; for(k=1;k;k++) ... MaxNu
  • 就目前而言,我只考虑其特征向量特征值也是实数的实矩阵。我目前正在为特征向量解决问题。这是我到目前为止:public double[] getBasis(double[][] basis){double a = basis[0][0];double b = basis[0][1];double ...
  • Java OpenCV 图像处理26.0 HOG 特征提取

    千次阅读 2019-08-04 20:31:12
    @[TOC](Java OpenCV-4.0.0 图像处理26.0 HOG特征提取)) package com.xu.opencv.ml; import org.opencv.core.Core; import org.opencv.core.Mat; import org.opencv.core.MatOfDouble; import org.opencv.core....
  • 目录:前言1、高斯尺度空间GSS2、高斯差分DOG用DoG检测特征点GSS尺度选择3、图像金字塔建立用前一个octave中的倒数第三幅图像生成下一octave中的第一幅图像每层octave为什么生成s+3幅图像4、高斯核性质在SIFT中的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,973
精华内容 5,989
关键字:

java 特征值转特征向量

java 订阅
友情链接: app.zip