package com.whyc.util;
|
|
import com.whyc.dto.Response;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.text.DecimalFormat;
|
import java.text.ParseException;
|
import java.util.*;
|
|
/**
|
* 计算工具类
|
*/
|
public class MathUtil {
|
|
public static final Integer TYPE_FLOAT = 1;
|
public static final Integer TYPE_FLOAT_100 = 2;
|
public static final Integer TYPE_FLOAT_PERCENT = 3;
|
/**
|
* 提取公共方法,相除获取比例,返回可选String或者Float
|
* @param type 1表示小数,2表示除去%的比例,3表示%的比例
|
* @return Object String或者Float类型
|
* */
|
public static Object divide(Object num,Object num2,Integer type){
|
float res = 0;
|
double num2Double=Double.parseDouble(num2.toString());
|
if(num2Double!=0){
|
|
if (num instanceof Integer) {
|
res = BigDecimal.valueOf((Integer) num).divide(BigDecimal.valueOf((Integer) num2), 2, RoundingMode.HALF_UP).floatValue();
|
}
|
if (num instanceof Float) {
|
res = BigDecimal.valueOf((Float) num).divide(BigDecimal.valueOf((Float) num2), 2, RoundingMode.HALF_UP).floatValue();
|
}
|
if (num instanceof Double) {
|
res = BigDecimal.valueOf((Double) num).divide(BigDecimal.valueOf((Double) num2), 2, RoundingMode.HALF_UP).floatValue();
|
}
|
}
|
//0.05
|
if (type == 1) {
|
return res;
|
}
|
//5
|
else if (type == 2) {
|
return (int) (res * 100);
|
}
|
//5%
|
return (int) (res * 100) + "%";
|
}
|
|
/**
|
* 提取公共方法,相除获取比例,返回可选String或者Float
|
* @param type 1表示小数,2表示除去%的比例,3表示%的比例
|
* @return Object String或者Float类型
|
* */
|
public static Object divide(Object num, Object num2, Integer type, Integer scale){
|
Object res = 0;
|
double num2Double=Double.parseDouble(num2.toString());
|
double numDouble=Double.parseDouble(num.toString());
|
if(num2Double!=0){
|
//0.05
|
if (type == 1) {
|
res = BigDecimal.valueOf(numDouble).divide(BigDecimal.valueOf(num2Double), scale, RoundingMode.HALF_UP).floatValue();
|
}
|
//5
|
else {
|
BigDecimal multiply = BigDecimal.valueOf(numDouble).multiply(BigDecimal.valueOf(100));
|
BigDecimal divide = multiply.divide(BigDecimal.valueOf(num2Double), scale, RoundingMode.HALF_UP);
|
if (type == 2) {
|
res = divide.floatValue()+"";
|
}
|
//5%
|
else{
|
res = divide.floatValue()+"%";
|
}
|
}
|
return res;
|
}else{
|
if(type == 1){
|
return 0.0;
|
}else{
|
if(type==2){
|
return "0";
|
}else{
|
return "0%";
|
}
|
}
|
}
|
}
|
|
public static float multiply(float num,float num2,int scale){
|
return BigDecimal.valueOf(num).multiply(BigDecimal.valueOf(num2)).setScale(2,RoundingMode.HALF_UP).floatValue();
|
}
|
|
/**
|
* 求自变量X,因变量Y的线性回归 @PerryHsu
|
* y = ax+b
|
*
|
* a = ∑Yi(Xi-X的平均值)/∑(Xi^2)-1/n*(∑(Xi^2)
|
*
|
* b = 1/n*∑(Yi-aXi)
|
*
|
* */
|
public static Response linearRegressionUnary(List<Double> listX, List<Double> listY,Double x) {
|
List<Double> resList = new LinkedList<>();
|
|
int sizeX = listX.size();
|
int sizeY = listY.size();
|
DecimalFormat df = new DecimalFormat("0.##");
|
|
if (sizeX != sizeY) {
|
return new Response<>().set(1,false,"分子分母数量不一致。");
|
}
|
|
Double sum = 0d;
|
for (Double xi : listX) {
|
sum += xi;
|
}
|
double avgX = sum/ sizeY;
|
|
//a的分子
|
double aMolecule = 0;
|
for (int i = 0; i < sizeX; i++) {
|
aMolecule += listY.get(i) * (listX.get(i) - avgX);
|
}
|
|
//a的分母
|
double aDenominator = 0;
|
int aDenominatorXi = 0;
|
for (int i = 0; i < sizeX; i++) {
|
aDenominator += Math.pow(listX.get(i), 2);
|
aDenominatorXi += listX.get(i);
|
}
|
aDenominator = aDenominator - (1.0 / sizeX) * (Math.pow(aDenominatorXi, 2));
|
|
//System.out.println("w_denominator:"+w_denominator+" w_denominator_xi:"+w_denominator_xi);
|
|
double a = aMolecule / aDenominator;
|
|
double b = 1.0 / sizeX;
|
double sumYAX = 0;
|
for (int i = 0; i < sizeX; i++) {
|
sumYAX += (listY.get(i) - a * listX.get(i));
|
}
|
b = b * sumYAX;
|
|
String symbol = "+";
|
if (b < 0) {
|
symbol = "";
|
}
|
//System.out.println("y=" + df.format(a) + "x" + symbol + df.format(b));
|
|
Double y = a*x + b;
|
resList.add(a);
|
resList.add(b);
|
resList.add(y);
|
return new Response().setII(1,true,resList,null);
|
}
|
|
public static void main(String[] args) throws ParseException {
|
|
/*List<Double> x = Arrays.asList(5d, 9d, 15d, 19d, 19d, 45d);
|
|
List<Double> y = Arrays.asList(4d, 6d, 12d, 15d, 15d, 37d);*/
|
//按照年为单位为x.变化差值为y
|
/*List<Double> x = Arrays.asList(
|
DateUtil.YYYY_MM_DD_HH_MM_SS.parse("2021-04-13 09:14:36").getTime()*1d,
|
DateUtil.YYYY_MM_DD_HH_MM_SS.parse("2021-10-14 13:46:36").getTime()*1d,
|
DateUtil.YYYY_MM_DD_HH_MM_SS.parse("2022-03-18 11:08:36").getTime()*1d,
|
DateUtil.YYYY_MM_DD_HH_MM_SS.parse("2022-03-18 13:56:36").getTime()*1d);
|
|
List<Double> y = Arrays.asList(
|
99d,
|
80d,
|
71.9d,
|
71d);*/
|
/*long time1 = DateUtil.YYYY_MM_DD_HH_MM_SS.parse("2021-04-13 09:14:36").getTime();
|
long time2 = DateUtil.YYYY_MM_DD_HH_MM_SS.parse("2021-10-14 13:46:36").getTime();
|
long time3 = DateUtil.YYYY_MM_DD_HH_MM_SS.parse("2022-03-18 11:08:36").getTime();
|
long time4 = DateUtil.YYYY_MM_DD_HH_MM_SS.parse("2022-03-18 13:56:36").getTime();
|
long time5 = DateUtil.YYYY_MM_DD_HH_MM_SS.parse("2023-03-12 13:56:36").getTime();*/
|
long time1 = ThreadLocalUtil.parse("2021-04-13 09:14:36",1).getTime();
|
long time2 = ThreadLocalUtil.parse("2021-10-14 13:46:36",1).getTime();
|
long time3 = ThreadLocalUtil.parse("2022-03-18 11:08:36",1).getTime();
|
long time4 = ThreadLocalUtil.parse("2022-03-18 13:56:36",1).getTime();
|
long time5 = ThreadLocalUtil.parse("2023-03-12 13:56:36",1).getTime();
|
|
double c1 = 99d;
|
double c2 = 98d;
|
double c3 = 96.9d;
|
double c4 = 95d;
|
|
List<Double> x = Arrays.asList(
|
0d,
|
(time2-time1)*1d/1000/60/60/24,
|
(time3-time1)*1d/1000/60/60/24,
|
(time4-time1)*1d/1000/60/60/24
|
);
|
|
|
List<Double> y = Arrays.asList(
|
c1,
|
c2,
|
c3,
|
c4
|
);
|
double v = (time5 - time1) * 1d / 1000 / 60 / 60 /24;
|
System.out.println(v);
|
Response response = linearRegressionUnary(x, y, v);
|
System.out.println(response);
|
}
|
|
|
/**
|
*
|
* @param startNum 起始数 -1 = limitStart ,因为limit是从0开始
|
* @param endNum 终止数
|
* @param pageSize 每页条数
|
* @param queryCountMap key-年份,value-数量
|
* @return {"2023",[2,20]}
|
* 表名,[limit 2,20]
|
*/
|
public static Map<String, List<Integer>> getQueryTableAndLimit(int startNum, int endNum, int pageSize, Map<String, Integer> queryCountMap) {
|
Map<String,List<Integer>> resultMap = new LinkedHashMap<>();
|
//定位起始数,在哪个年份范围内,起始数值;终止数,在哪个年份范围内,终止数值
|
Set<String> queryKeySet = queryCountMap.keySet();
|
int sum = 0;
|
int lastSum = 0;
|
|
String limitStartYear = null;
|
int limitStart = 0;
|
String limitEndYear = null;
|
int limitEndSize = pageSize;
|
boolean limitStartFinished = false;
|
for (String queryKey : queryKeySet) {
|
int queryCount = queryCountMap.get(queryKey);
|
sum+=queryCount;
|
if(!limitStartFinished) {
|
if (startNum <= sum) {
|
limitStart = startNum - lastSum;
|
limitStartYear = queryKey;
|
//完成了limit 起始值的获取,后续不需要继续执行
|
limitStartFinished = true;
|
}
|
}
|
if(limitStartFinished) { //limit 起始值获取后,开始计算终止的记录数量
|
if (endNum <= sum) {
|
limitEndYear = queryKey;
|
|
break;
|
}
|
//首次,执行起始limit的时候, limitEndSize(记录预留的查询个数)需要减去limitStart占用的
|
if(limitEndSize == pageSize){
|
limitEndSize = pageSize - (sum - startNum + 1);
|
}else{ //如果还没达到 终止数值,需要减去本次查询消耗掉的数量
|
limitEndSize = limitEndSize - queryCount;
|
}
|
}
|
|
lastSum = sum;
|
}
|
|
boolean limitStartCompareFlag = true;
|
boolean tableStartFlag = false;
|
for (String queryKey : queryKeySet) {
|
int queryCount = queryCountMap.get(queryKey);
|
if(queryKey.equals(limitStartYear) && limitStartCompareFlag){
|
tableStartFlag = true;
|
//从这里开始,取记录数
|
LinkedList<Integer> limitList = new LinkedList<>();
|
if(queryKey.equals(limitEndYear)) { //同一年
|
limitList.add(limitStart-1);
|
limitList.add(pageSize);
|
resultMap.put(queryKey,limitList);
|
break;
|
}else{
|
limitList.add(limitStart-1);
|
limitList.add(queryCount);
|
resultMap.put(queryKey,limitList);
|
}
|
limitStartCompareFlag = false;
|
continue;
|
}
|
//不同年,继续
|
if(tableStartFlag) { //已经经过了起始年,才可以取数据. 起始年前的数据无效
|
if (queryKey.equals(limitEndYear)) { //找到终止年
|
LinkedList<Integer> limitList = new LinkedList<>();
|
limitList.add(0);
|
limitList.add(limitEndSize);
|
resultMap.put(queryKey, limitList);
|
break;
|
} else { //不是终止年,属于中间年
|
LinkedList<Integer> limitList = new LinkedList<>();
|
limitList.add(0);
|
limitList.add(queryCount);
|
resultMap.put(queryKey, limitList);
|
}
|
}
|
}
|
return resultMap;
|
}
|
}
|
