java代码----实现因子分析算法

最新推荐文章于 2023-06-03 08:41:41 发布
置顶 最新推荐文章于 2023-06-03 08:41:41 发布
阅读量1.6k 收藏 7
点赞数 2
分类专栏： java 因子分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ITzym/article/details/83380184
版权

许久没有管自己的博客了，问我要源码的亲们，现在可以看了，希望可以帮到你们。

代码如下：

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import Jama.Matrix;
import Util.DBConnection;

//因子分析
public class FactorAnalyse {
	// 从数据库中获取数据
	public double[][] getHseData(){
		List<Double> list = new ArrayList<Double>();
		double[][] result = new double[24][26];
		double[] temp = new double[24*26];
		
		String sql = "select score from HseScore";
		ResultSet rs = DBConnection.executeQuery(sql);
		try{
			while(rs.next()){
				list.add(rs.getDouble(1));
			}
		}catch(SQLException e){
			e.printStackTrace();
		}
		for(int i=0;i<list.size();i++){
			temp[i] = list.get(i);
		}
		for (int i = 0; i < 24; i++) {
			for (int j = 0; j < 26; j++) {
				result[i][j] = temp[26*i+j];
			}
		}
		Matrix m = new Matrix(result);
		m.print(3, 2);
		return result;
	}
	// 计算均值
	public double[] getAverage(double[][] array) {
		int h = array.length; // 行号--h
		int l = array[0].length;// 列号--l
		double[] average = new double[l];// 每个变量的均值
		for (int i = 0; i < l; i++) {
			double temp = 0.0;
			for (int j = 0; j < h; j++) {
				temp += array[j][i];
			}
			average[i] = temp / h;
			// System.out.printf("average[%d] = %.5f\n", i, average[i]);
		}
		return average;
	}

	// 计算方差
	public double[] getVariance(double[][] array) {
		int h = array.length; // 行号--h
		int l = array[0].length;// 列号--l
		double[] average = getAverage(array);
		double[] var = new double[l];

		for (int i = 0; i < l; i++) {
			double temp = 0.0;
			for (int j = 0; j < h; j++) {
				temp += Math.pow((array[j][i] - average[i]), 2);
			}
			var[i] = temp / (h - 1);
			// System.out.printf("var[%d] = %.5f\n", i, var[i]);
		}
		return var;
	}

	// 计算标准差
	public double[] getStandardDevition(double[] var) {
		double[] sd = new double[var.length];

		for (int i = 0; i < var.length; i++) {
			sd[i] = Math.sqrt(var[i]);
			// System.out.printf("sd[%d] = %.5f\n", i, sd[i]);
		}
		return sd;
	}

	// 标准化数据
	public double[][] getStandard(double[][] array, double[] sd) {
		int h = array.length; // 行号--h
		int l = array[0].length;// 列号--l
		double[][] result = new double[h][l];// 标准化
		double[] average = getAverage(array);

		for (int i = 0; i < h; i++) {
			for (int j = 0; j < l; j++) {
				result[i][j] = (array[i][j] - average[j]) / sd[j];
			}
		}
		Matrix m = new Matrix(result);
		m.print(5, 3);
		
		return result;
	}

	// 计算协方差矩阵--方阵
	public double[][] getCovMatrix(double[][] array) {
		int h = array.length;
		int l = array[0].length;
		double[][] temp = new double[h][l];// 保存计算协方差的中间矩阵
		double[][] result = new double[l][l];
		double[] average = getAverage(array); // 标准化后的矩阵求均值

		for (int i = 0; i < h; i++) {
			for (int j = 0; j < l; j++) {
				temp[i][j] = array[i][j] - average[j];
			}
		}
		for (int i = 0; i < l; i++) {
			for (int j = 0; j < l; j++) {
				double t = 0;
				for (int k = 0; k < h; k++) {
					t += temp[k][i] * temp[k][j];
				}
				result[i][j] = t / (h - 1);
			}
		}
		Matrix m = new Matrix(result);
		m.print(5, 3);
		
		return result;
	}

	// 计算相关矩阵---方阵
	public double[][] getCorrelationMatrix(double[][] cov, double[] sd) {
		int l = cov.length;
		double[][] result = new double[l][l];

		for (int i = 0; i < l; i++) {
			for (int j = 0; j < l; j++) {
				result[i][j] = cov[i][j] / (sd[i] * sd[j]);
			}
		}
		Matrix m = new Matrix(result);
		m.print(5, 3);
		return result;
	}

	// 求矩阵特征值
	public double[][] getEigenvalue(double[][] array) {
		int h = array.length;// 行号等于列号
		double[][] result = new double[h][h];

		Matrix m = new Matrix(array);
		Matrix m1 = m.eig().getD(); // 由特征值组成的对角矩阵
		System.out.println("由特征值组成的对角矩阵：");
		m1.print(5, 3);
		result = m1.getArray();
		
		return result;
	}

	// 求矩阵的特征向量
	public double[][] getEigenvector(double[][] array) {
		int h = array.length;// 行号等于列号
		double[][] result = new double[h][h];

		Matrix m = new Matrix(array);
		Matrix m1 = m.eig().getV(); // 该矩阵的每一列对应的是一个单位正交特征向量
		System.out.println("\n特征向量矩阵：");
		m1.print(5, 3);
		result = m1.getArray();
		
		return result;
	}

	// 特征值从大到小排序并保存成键值对形式
	public TreeMap<Integer, Double> getMap(double[][] array) {
		int h = array.length;
		Map<Integer, Double> map = new HashMap<Integer, Double>();
		ValueComparator bvc = new ValueComparator(map);
		TreeMap<Integer, Double> sorted_map = new TreeMap<Integer, Double>(bvc);
		double[] temp = new double[h]; // 存储特征值
		for (int i = 0; i < h; i++) {
			for (int j = 0; j < h; j++) {
				if (i == j)
					temp[i] = array[i][j];
			}
		}
		for (int i = 0; i < temp.length; i++) {
			map.put(i, temp[i]);
		}
		System.out.println("\n排序前键值对：\n" + map);
		sorted_map.putAll(map);
		System.out.println("\n排序后的键值对：\n" + sorted_map);

		return sorted_map;
	}

	// 计算方差贡献率
	public double[] getContibutionRatio(TreeMap<Integer, Double> tm) {
		int h = tm.size();
		double[] percent = new double[h];
		Iterator titer = tm.entrySet().iterator();
		int count = 0;
		
		while (titer.hasNext()) {
			Map.Entry ent = (Map.Entry) titer.next();
			int keyt = (Integer) ent.getKey();
			double valuet = (Double) ent.getValue();
			percent[count] = valuet / h;
			System.out.printf("\n键%d 对应的特征值 %.3f所占的比例为  %.3f \n",keyt,valuet,percent[count]);
			count++;
		}
		return percent;
	}

	// 计算方差累积贡献率
	public double[] getCumuContributionRatio(double[] array) {
		double[] result = new double[array.length];
		double temp = 0.0;
		for (int i = 0; i < array.length; i++) {
			temp += array[i];
			result[i] = temp;
			System.out.printf("\n累积贡献率：%.3f \n", result[i]);
		}
		return result;
	}

	// 确定公共因子的个数
	public int getNum(double[] array) {
		int number = 1;// 公因子个数
		double t = 0.0;
		for (int i = 0; i < array.length; i++) {
			t = array[i];
			if (t < 0.75)
				number++;
		}
		System.out.println("\n公共因子个数：" + number);
		return number;
	}

	// 获取特征值对应的特征向量
	public double[][] getVVector(TreeMap<Integer, Double> tm, double[][] array) {
		int h = array.length;
		double[][] result = new double[h][h];
		int[] temp = new int[h];
		Iterator titer = tm.entrySet().iterator();
		int count = 0;
		while (titer.hasNext()) {
			Map.Entry ent = (Map.Entry) titer.next();
			int keyt = (Integer) ent.getKey();
			temp[count] = keyt;
			// System.out.println("temp["+count+"] = "+temp[count]);
			count++;
		}
		for (int i = 0; i < h; i++) {
			for (int j = 0; j < h; j++) {
				result[i][j] = array[i][temp[j]];
			}
		}
		System.out.println("特征值对应的特征向量组成的矩阵：");
		Matrix m = new Matrix(result);
		m.print(5, 3);
		return result;
	}

	// 获取因子载荷矩阵
	public double[][] getMatrixA(TreeMap<Integer, Double> tm, double[][] array,
			int num) {
		int h = array.length;
		double[][] A = new double[h][num];
		double[] temp = new double[h];
		Iterator titer = tm.entrySet().iterator();
		int count = 0;
		while (titer.hasNext()) {
			Map.Entry ent = (Map.Entry) titer.next();
			double valuet = (Double) ent.getValue();
			temp[count] = Math.sqrt(valuet);
			// System.out.printf("特征值开平方根：%.5f\n", temp[count]);
			count++;
		}
		System.out.println("因子载荷矩阵 A = ");
		for (int i = 0; i < h; i++) {
			for (int j = 0; j < num; j++) {
				A[i][j] = temp[j] * array[i][j];
			}
		}
		Matrix m = new Matrix(A);
		m.print(5, 3);
		return A;
	}

	// 获取特殊因子矩阵
	public double[][] getMatrixD(TreeMap<Integer, Double> tm, double[][] array,
			int num) {
		int h = array.length;
		double[][] B = new double[h][h - num];
		double[][] C = new double[h][h];
		double[][] D = new double[h][h];
		double[] temp = new double[h];
		Iterator titer = tm.entrySet().iterator();
		int count = 0;
		while (titer.hasNext()) {
			Map.Entry ent = (Map.Entry) titer.next();
			double valuet = (Double) ent.getValue();
			temp[count] = Math.sqrt(valuet);
			count++;
		}
		for (int i = 0; i < h; i++) {
			for (int j = num; j < h; j++) {
				B[i][j - num] = temp[j] * array[i][j];
			}
		}
		Matrix m = new Matrix(B);
		Matrix m1 = m.times(m.transpose());
		C = m1.getArray();
		for (int i = 0; i < h; i++) {
			for (int j = 0; j < h; j++) {
				if (i == j)
					D[i][j] = C[i][j];
			}
		}
		System.out.println("特殊因子矩阵 D = ");
		Matrix m2 = new Matrix(D);
		m2.print(5, 3);
		return D;
	}	
	
	// 进行因子旋转--方差最大正交旋转
	public double[][] getVarimax(double[][] array, int num) {
		int h = array.length;
		int l = array[0].length;
		double[] hi = new double[h]; // 变量共同度
		double[][] standardA = new double[h][l];//标准化处理因子载荷阵
		double[][] result = new double[h][l];// 旋转后的因子载荷矩阵
		double[] u = new double[h];
		double[] v = new double[h];
		double A = 0.0;
		double B = 0.0;
		double C = 0.0;
		double D = 0.0;
		double E = 0.0;
		//标准化处理A
		for (int i = 0; i < h; i++) {
			double temp = 0.0;
			for (int j = 0; j < l; j++) {
				temp += Math.pow(array[i][j], 2);
			}
			hi[i] = temp;
			//System.out.printf("变量共同度：%.5f\n", hi[i]);
		}
		for(int i = 0; i < h; i++){
			for(int j = 0; j < l; j++){
				standardA[i][j] = Math.pow(array[i][j],2) / hi[i];
			}
		}
	
		double[][] P = new double[l][l]; // 构造正交矩阵
		Matrix m = new Matrix(standardA);
		for (int k = 0; k < num-1; k++) {
			for (int p = k+1; p < num; p++) {
				for (int i = 0; i < h; i++) {
					u[i] = (Math.pow(array[i][k], 2) - Math.pow(array[i][p], 2)) / hi[i];
				}
				for (int i = 0; i < h; i++) {
					v[i] = (2 * array[i][k] * array[i][p]) / hi[i];
				}
				for (int i = 0; i < h; i++) {
					A += u[i];
					B += v[i];
					C += (u[i] * u[i]) - (v[i] * v[i]);
					D += 2 * u[i] * v[i];
				}
				E = (Math.atan((D - (2 * A * B) / h) / (C - (A * A - B * B) / h))) / 4.0;
				//System.out.printf("\n旋转角度 E = %.5f\n", E);
				for (int i = 0; i < l; i++) {
					for (int j = 0; j < l; j++) {
						if (i == j)
							P[i][j] = 1;
						else
							P[i][j] = 0;
					}
				}
				double[][] T = P;
				T[k][k] = Math.cos(E);
				T[k][p] = -Math.sin(E);
				T[p][k] = Math.sin(E);
				T[p][p] = Math.cos(E);
				Matrix m1 = new Matrix(T);//正交矩阵
				m = m.times(m1);
			}
		}
		m.print(5, 3);
		result = m.getArray();
		return result;
	}
	// 计算旋转后的方差贡献率
		public double[] getContibutionRatio1(double[][] array) {
			int h = array.length;
			int l = array[0].length;
			double[] percent = new double[h];
			double sum = 0.0;
			for(int i = 0; i < l;i++){
				double temp = 0.0;
				for(int j = 0; j < h;j++){
					temp += Math.pow(array[j][i],2);
				}
				percent[i] = temp / h; 
				//System.out.printf("\n旋转后的方差贡献率--F["+(i+1)+"]: %.3f\n",percent[i]);
				sum += percent[i];
			}
			//System.out.printf("\n方差累积贡献率：:%.3f\n",sum);
			return percent;
		}
	// 计算因子载荷的方差
		public double getA_Var(double[][] array) {
			int h = array.length;
			int l = array[0].length;
			double[] var = new double[l];// 每一列的方差
			double v = 0.0;// 总方差
			double[][] B = new double[h][l];
			
			for (int i = 0; i < h; i++) {
				for (int j = 0; j < l; j++) {
					B[i][j] = Math.pow(array[i][j],2);
				}
			}
			double[] ad = getAverage(B);
			for (int i = 0; i < l; i++) {
				double temp = 0.0;
				for (int j = 0; j < h; j++) {
					temp += Math.pow(B[j][i] - ad[i], 2);
				}
				var[i] = temp / h;
				//System.out.printf("每一列的方差：%.5f\n", var[i]);
				v += var[i];
			}
			System.out.printf("总方差：%.3f\n", v);
			return v;
		}
		
	// 计算因子得分
	public double[][] getScore(double[][] R, double[][] A,double[][] array) {
		int h = A.length;
		int l = R[0].length;
		double[][] F = new double[h][l];

		Matrix m = new Matrix(A);
		Matrix m1 = new Matrix(R);
		Matrix m2 = (m.transpose()).times(m1.inverse());
		Matrix m3 = new Matrix(array);
		Matrix m4 = (m2).times(m3.transpose());
		System.out.println("因子得分：");
		m4.transpose().print(5, 3);
		F = m4.transpose().getArray();
		return F;
	}
	//计算因子综合得分
	public double[] getScores(double[][] array,double[] percent){
		int h = array.length;
		int l = array[0].length;
		double[] result = new double[h];
		double temp = 0.0;
		
		for(int i = 0; i < l; i++){
			temp +=percent[i];
		}
		for(int i = 0; i < h; i++){
			double t = 0.0;
			for(int j = 0; j < l; j++){
				t += array[i][j] * percent[j];
			}
			result[i] = t / temp;
			System.out.printf("综合得分：%.3f\n",result[i]);
		}
		return result;
	}
}
// map按值进行排序
class ValueComparator implements Comparator<Integer> {

	Map<Integer, Double> base;

	public ValueComparator(Map<Integer, Double> base) {
		this.base = base;
	}

	public int compare(Integer a, Integer b) {
		if (base.get(a) >= base.get(b)) {
			return -1;
		} else {
			return 1;
		}
	}
}

完整代码已贴出，有需要的朋友请查看，转载请注明出处，谢谢！

ITzym
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
【Java】基于TA-Lib量化分析研究.pdf
11-06
近期项目中有需要构建一个量化分析模块，能够实现常规的各种技术指标，并可以自由扩展添加客户创建的技术指标。同时，能够基于本地打造的数据平台，能够给出1-2中策略模型来打通整体数据从采集到最终生产的过程。经过调查，TA-Lib库中已经有超多实现的技术指标，可以节省从零开始造轮子的精力。本次给客户开发的平台都是基于J2EE开发的，所以采用了TA-Lib的Java版本JAR进行开发（主要是开发人员都是Java，项目组没有Python ，否则应该使用更加方便）。
因子分析法--用Java语言设计算法
ITzym的博客
04-22 3591
懂了因子分析的原理，再来根据实际问题设计算法。 样本数据标准化—公式如下： java实现代码如下： // 计算期望与标准差,标准化数据 public double[][] getStandard(double[][] array) { int h = array.length; // 行号--h int l = array[0].length;// 列号
java因子分析_因子分析（Factor Analysis）
weixin_35682132的博客
02-28 689
1 问题之前我们考虑的训练数据中样例的个数m都远远大于其特征个数n，这样不管是进行回归、聚类等都没有太大的问题。然而当训练样例个数m太小，甚至m<多元高斯分布的参数估计公式如下：分别是求mean和协方差的公式，表示样例，共有m个，每个样例n个特征，因此是n维向量，是n*n协方差矩阵。当m<是奇异阵()，也就是说不存在，没办法拟合出多元高斯分布了，确切的说是我们估计不出来。如果我们仍然想...
平衡二叉树完整java代码_数据结构-平衡二叉树 旋转过程平衡因子分析 c和java代码实现对比...
weixin_42300400的博客
02-24 123
public classAVL {private boolean taller=false;private Node root =null;private static final int EH=0;private static final int LH=1;private static final int RH=-1;private classNode{public intdata;public...
因子分析——流程与实现stata
热门推荐
大太阳的博客
12-08 5万+
题外话——为质数而生的蝉 有些蝉会展现出令人吃惊的特征：它们集体探出土壤的时间通常都跟13和17这样的质数年同步，此时大概会有150万只以上的成蝉在短时间内同时出现在一英亩的土地上。来自-《The Math Book》 这样的特征可能带来两个好处： 1）根据质数的性质它只能被1和自身整除，那么它大概率会被生命周期是1和探出土壤年份的猎食者捕杀（可能不那么严谨哈），例如如果周期是12年的动物，可能被周期是1,2,3,4,6,12年的天敌捕杀。 2）13,17两个质数的最小公倍数是两个数乘积，意味着20
java代码-分解数求余数
07-15
以上就是关于“java代码-分解数求余数”的详细解释，包括如何找到一个数的因子，如何对因子求余数，以及如何在Java中实现这些功能。希望这个解释能帮助你更好地理解和应用这些概念。如果你需要进一步的信息或有其他...
java代码-100里的素数
07-15
综上所述，"java代码-100里的素数"涵盖了Java编程基础、素数判断算法、代码实现、优化策略和项目文档等多个知识点。通过这个项目，你可以进一步巩固Java编程技能，同时对素数及其判断方法有更深的理解。
java代码-解密rsa
07-16
RSA是一种非对称加密算法，它是公钥密码学的一个重要里程...由于没有提供具体文件内容，无法详细分析代码细节，但以上是RSA解密的基本概念和Java实现流程。在实际项目中，还可能涉及证书管理、异常处理和其他安全实践。
java代码-1到100素数
07-15
标题中的“java代码-1到100素数”指的是使用Java编程语言编写的一个程序，其目的是找出并打印出1到100之间的所有素数。素数是大于1的自然数，它只能被1和它自身整除，不能被其他正整数整除。在计算机科学中，这个...
java代码-猴子偷桃。
07-15
通过以上分析，我们可以看出“java代码-猴子偷桃”是一个关于算法和数据结构的实例，它展示了如何用Java编程语言解决实际问题，同时锻炼了程序员的逻辑思维和算法设计能力。在实际开发中，类似的问题可能出现在资源...
matlab-因子分析-源代码
02-16
matlab-因子分析-源代码
因子分析法在学生Java成绩及学习行为中的应用.pdf
07-02
因子分析法在学生Java成绩及学习行为中的应用.pdf
北大版因子分析法教程
02-26
因子分析法教程 ppt 北大版，详细较少了几个案例，分析过程很好的
因子分析实现
kmmel的博客
04-14 2121
在对数据进行因子分析之前需要先对数据进行KMO检验，计算 KMO 值，我们可以根据结果来判断数据集是否适合使用因子分析或其他降维方法。一般来说，如果 KMO 值大于0.6，则数据集具有较好的因子结构，可以考虑使用因子分析等技术来分析数据；如果 KMO 值小于0.6，则数据集可能不适合使用因子分析等技术，需要进一步检查数据集的质量并重新评估分析方法。需要注意的是，如果 Bartlett 球形度检验的 p 值小于显著性水平（通常为 0.05），则表明数据集不适合使用因子分析或相关技术。
因子分析 FA | Factor Analysis
最新发布
JasonH2021的博客
06-03 4817
本文主要简单介绍了因子分析的基本概念，优缺点，应用场景，建模过程，建模时的注意事项，评价指标，实现方法，python示例和模型参数等。
java因子分析,SPSS统计分析全解析▶主成分分析与因子分析
weixin_29340419的博客
03-21 359
因子分析往往成为更复杂的多元分析方法的基础=======================================================主成分分析==============================================================因子分析样本量与变量数的比例虽然最好是5:1以上，但是也要结合实际情况来看。达不到这个标准也是可以的。还是使用上面...
量化java_用java做量化
weixin_34952098的博客
02-12 2367
这篇文章是对目前我自己用java开发量化交易系统的一个总结，后续有新的进展我会陆续更新到这个专栏里。用业余时间搞量化这个副业是想实现自己一直以来的愿望：当一个自由的宽客(其实大部分是因为不满足于死工资)想做量化已经有4-5年了，记得大学的时候第一次在网上看到宽客这个名词，当时心里很激动。第一，当宽客很自由，而且能发挥个人的聪明才智，大学时在学校里参加过数据建模竞赛，我对能够用模型描述解决现实问题的...
因子分析模型 - 因子分析法原理与代码实现 -（Python，R）
黄饱饱
11-20 3万+
因子分析基本思想 和主成分分析相似，首先从原理上说，主成分分析是试图寻找原有自变量的一个线性组合，取出对线性关系影响较大的原始数据，作为主要成分。 因子分析，是假设所有的自变量可以通过若干个因子（中间量）被观察到。什么意思呢，举个例子，比如一个学生的考试成绩，语文80，数学95，英语79，物理97，化学94 ，那么我们认为这个学生理性思维较强，语言组织能力较弱。其中理性思维和语...
算法分析：渐近分析与Java数据结构
为了分析算法的效率，我们常常使用**大O符号**来描述算法的时间复杂度，它表示算法最坏情况下的时间代价增长速度。例如，O(1)表示常数时间复杂度，O(n)表示线性时间复杂度，O(n^2)表示二次时间复杂度，以此类推。...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值