统计学

本文记录《统计学》学习

恶补高等数学

1. 导数

   y=ax+b
   dy = f′(x)dx
   f′(x) = dy/dx 导数

2. 偏导数
   当一个函数有多个变量时，对每个变量求导为偏导数

   z = f(x,y)
   // 对x的偏增量，偏增量除以x的增量，记为偏导数
   dZx = f(x+dx,y)-f(x,y)
   对x的偏导数 = dZx/dx

3. 全微分
   如果一个函数有多个变量，下面计算全增量

   z= f(x,y)
   dz = f(x+dx,y+dy)-f(x,y)≈Adx+Bdy  这是全增量（后面还有一个高阶无穷小）
   有一个定理
   dz = f′x(x,y)dx+f′y(x,y)dy 其中 f′x(x,y)为对x的偏导数

4. 方向导数
   在一点，沿任意方向的导数

   在某一方向的导数=f′x(x,y)cosA+f′y(x,y)cosB

5. 梯度

   在某一点的梯度= (f′x(x,y),f′y(x,y))*(cosA,cosB)
   (f′x(x,y),f′y(x,y))=gradf(x,y) 记为一个新向量

统计含义

1. 统计工作是指收集、整理和分析统计数据并探索数据内在数量规律的活动过程

2. 统计资料是统计工作过程所取得的各种数字资料和各种其它资料的总称

3. 统计学是研究如何收集、整理和分析客观现象数据，认识客观现象总体和数量特征和数量规律的方法论科学。

4. 组数的确定：Sturges经验公式K=1+3.32lgN，其中K为组数，N为总体容量或数据的个数。

5. 组距一般采用等距组距，等于d>=R/K=(Xmax-Xmin)/(1+3.32lgN)，Xmax为全部数值的最大值，Xmin为全部数值的最小值，R也称为极差，d最好取5或10的倍数

6. 组距分组时的组限有两种：重叠组限和间断组限，重叠组限规定它的上限不在该组内，最小值为该组的下限，且包含在该组内。组距为重叠组的上限减去重叠组的下限。注意：如果采用间断组限则上限为后一个组的下限

7. 向上累加频数：从小到大累加，向下累加频数：从大到小。例如：

   const data= [1,2,3,4,5,6];
   // 向上累加
   const U = [1,3,6,10,15,21];
   // 向下累加
   const L =[21,20,18,15,11,6]

众数计算

1. 定性数据确定众数：找出出现频数或频率最多的变量值；
2. 数值型数据确定众数：（1）根据单变量值分组数据确定众数：找出出现频数或频率最多的变量值；
   （2）根据组距分组数据确定众数：先确定众数组，再确定众数。等距分组：众数组就是频数或频率最大的组；不等距分组：众数组是频数密度（改组的频数除以改组的组距）最大的组。

   // 根据下限计算众数
   const getMByLow = (L,f1,f2,f3,d) => {
       // L 众数组对应的下限，出现频数或频率最大的那个组
       // f1  众数组所在的频数
       // f2 众数组前一个组的频数
       // f3 众数组后一个组的频数
       // d 众数组的组距
       let M = L + (f1 - f2) / ((f1 - f2) + (f1 - f3)) * d 
       return M
   }
   
   const getMByUp = (U, f1, f2, f3, d) => {
       // U 众数组的上限
       // f1 众数组的频数
       // f2 众数组前一个的频数
       // f3 众数组后一个的频数
       // d 众数组的组距
       let M = U - ((f1 - f3) / (f1 - f2 + (f1 - f3))) * d; 
       return M
   }

分位数

将全部数据排序后，再等分为若干分位点，各等分位点上的数值称为分位数，分分位数有中位数，四分位、六分位等。不受极端值的影响。只有顺序和数值数据可以计算中位数。

1. 组距分组数据：N/2，其它数据分组方式(N+1)/2，N为全部数据的总个数。

2. 未分组和单变量值分组数据的中位数计算方式：当总数n为奇数时：Me=X((n+1)/2)，当n为偶数时：Me=(X(n/2)+X(n/2+1))/2，其中X(i)表示第i个数的值。

3. 组距分组：先根据中位数位置数值和向上或向下累计频数确定中位数所在的组，然后根据插值法计算中位数的数值。

   // 根据向下累计频数计算中位数
   const getMeByLow = (L,f1,f2,d,S1) => {
   
       // f1 数据总数，
       // f2 中位数所在组的频数，f1/2可以计算出中位数，然后通过向上累加计算出f1/2所在的组，知道了所在组，即可求出改组的频数f2
       // S1 中位数所在组的之前的向上累加的频数，例如f2所在组为4，计算1，2，3三个组的向上累加频数。
       // d 中位数所在组的组距
       // L 中位数所在组的下限
       let Me = L + (f1 / 2 - S1) / f2 * d
       return Me
   }
   
   // 根据向下累计频数计算中位数
   const getMeByUp = (U,f1,f2,d,S1) => {
   
       // f1 数据总数，
       // f2 中位数所在组的频数，f1/2可以计算出中位数，然后通过向下累加计算出f1/2所在的组，知道了所在组，即可求出改组的频数f2
       // S1 中位数所在组的之前的向下累加的频数，例如f2所在组为4，总的组数为9，计算9，8，7，6，5五个组的向下累加频数。
       // d 中位数所在组的组距
       // U 中位数所在组的上限
       let Me = U - (f1 / 2 - S1) / f2 * d
       return Me
   }

4. 四分位计算：未分组数据：下四分位数位置=(n+1)/4，上四分位数位置=(3(n+1))/4；分组数据：下四分位数位置=n/4，上四分位数位置=3n/4。

数值均值

定性数据无法计算数值均值。

1. 分组数据求均值，采用加权算术均值：各组变量值与各组的频数相乘，再除以变量值的总个数。

   // 计算分组加权均值
   const getAv = (data) => {
       // data是一个二维数组[[22,10],[23,10]]
       // 数组中每个元素的第一个表示组，第二个表示改组的频数
       // 注意，定性数据不能计算加权均值
       let a1 = 0;  // 每个元素的组*改组的频数
       let b1 = 0;  // 总频数
       for (let i = 0; i < data.length; i++){
           a1 += data[i][0] * data[i][1];
           b1 += data[i][1];
       }
       if (b1 !== 0) {
           return a1 / b1;
       }
       return "-"   
   }

加权调和均值

M/(M/x)，x是平均数，M是权数

几何均值

是N个变量值乘积的N次方根。注意：在算几何均值时N个变量值均不能为零，或当N为偶数时，它们的相乘结果不能为负数（负数开偶次方根，出来的是虚根，失去意义）

// 计算简单几何均值
const getSimXg = (data) => {
    // data一维数组
    let dataX = 1;
    for (let i = 0; i < data.length; i++){
        dataX *= data[i];
    }
    let Xg = Math.pow(dataX, 1 / data.length)
    return Xg;
}

// 计算加权几何均值
const getPowXg = (data) => {
    // data 二维数组
    // data = [[10,3],[15,1]]，
    // 每个元素第一个代表该组的变量值，第二个表示该变量值出现的频数
    let dataX = 1;
    let dataY = 0;
    for (let i = 0; i < data.length; i++){
        dataX *= Math.pow(data[i][0], data[i][1]);
        dataY += data[i][1];
    }
    let Xg = Math.pow(dataX, dataY) // dataX开dataY次方根
    return Xg
}

组中值

// 有上下限
const a1 = (b1,b2)=>{
    // b1 区间上限
    // b2 区间下限
    return (b1+b2)/2
}

// 只有上限
const a2 =(b1,b2)=>{
    // b1 区间上限
    // b2 相邻前一个的组距
    return b1 - b2/2
}

// 只有下限
const a3 =(b1,b2)=>{
    // b1 相邻后一个组的组距
    // b2 区间下限
    return b2+b1/2
}

均值之间的关系及其适用性

众数、中位数、算术均值的关系及其适用性

众数Mo，中位数Me和算术均值u大概有以下关系
Me-Mo≈2(u-Me)

异众比率

是非众数值的频数占全部变量值总频数的比重，异众比率的作用是衡量众数对一组变量值的代表性程度。

// 计算异众比率
const calVr = (f, f1) => {
    // f 是全部变量值总频数
    // f1 是众数的频数  
    // f -f1 就是非众数值的频数
    let Vr = (f - f1) / f
    return Vr
}

异众比率越大，说明非众数值的频数占比越大，则众数的代表性就越差。

全距

又称极差，是一组变量值的最大值与最小值之差。全距能够说明一组变量值的最大变动范围。

// 未分组数据
const calR1 = (x1,x2)=>{
    // x1 最大值
    // x2 最小值
    return x1-x2    
}

// 组距式分组数据
const calR2 = (x1,x2)=>{
    // x1 最高组上限
    // x2 最低组下限
    return x1-x2
}

内距

是一组变量值的上四分位数与下四分位数之差，也称为四分位差，反映了中间50%数据的离散程度，用IQR表示，衡量中位数的代表性，不受极端值的影响。

标准差

一组数据的每个值Xi与平均值u的差之和，为零，这个时候我们为了计算每个数据与平均值的差，可以先取每个值与平均数之差的绝对值，然后相加，最后再除以总数。

1. 平均差

   // 计算平均差
   const calAvSub = (data, av1) => {
       // data 是一维数组
       let da1 = 0;
       for (let i = 0; i < data.length; i++){
           da1 += Math.abs(data[i] - av1);
       }
       return da1/data.length
   }

2. 标准差，又称标准差，变异指标，标准差是方差的算术平方根（即方差等于标准差的平方）

   // 计算标准差
   const calAvStand = (data, av1) => {
       //data是一维数组
       let da1 = 0;
       for (let i = 0; i < data.length; i++){
           da1 += Math.pow(data[i]-av1,2)
       }
       return Math.pow(da1/data.length,0.5)
   }

3. 加权平均数计算总体方差和标准差

   // 加权总体方差
   const calD1 = (data,av1) => {
       // data 是二维数组，[[10,5],[54,3]]
       // 每个元素的第一个数代表元素的组中值，第二个元素代表频数
       let da1 = 0;  // 每个组的平方差乘以频数，最后将所有组相加的总和
       let db1 = 0;  // 总频数
       for (let i = 0; i < data.length; i++){
           let item = Math.pow(data[i][0] - av1, 2) * data[i][1];
           da1 += item;
           db1 += data[i][1];
       }
       return da1 / db1;
   }
   // 标准差等于方差开平方
   const d1 = Math.pow( calD1(data,av1),0.5);
   

在分组条件下，总体方差等于组间方差加组内方差的算术平均值，前面算的是组间方差，如果知道每个组内的分布情况，利用相同的计算原理，可以算出组内方差

离散程度

1. 离散程度：数据的差异程度。反映了各变量值远离其中心值的程度，又称离中趋势。
2. 变异指标：数据差异程度的测度值，又称离散程度测度值。作用：（1）判断算术均值对一组变量值代表性的高低。（2）判断社会经济活动过程的节奏性和风险程度。（3）变异指标是推断统计理论中一个很重要的基础指标。分类：异众比率、全距和内距、标准差和离散系数、标准分数。

离散系数

各变异指标与其算术均值的比值，是反映一组变量值相对离散程度的测度值。

// 离散系数=标准差/算术平均值
// 计算离散系数
// 加权总体方差
const calD1 = (data,av1) => {
    // data 是二维数组，[[10,5],[54,3]]
    // 每个元素的第一个数代表元素的组中值，第二个元素代表频数
    let da1 = 0;  // 每个组的平方差乘以频数，最后将所有组相加的总和
    let db1 = 0;  // 总频数
    for (let i = 0; i < data.length; i++){
        let item = Math.pow(data[i][0] - av1, 2) * data[i][1];
        da1 += item;
        db1 += data[i][1];
    }
    return da1 / db1;
}

const calF1 = (data, av1) => {
    // data 是二维数组，[[10,5],[54,3]]
    // 每个元素的第一个数代表元素的组中值，第二个元素代表频数
    // a1是变异指标，即标准差
    let a1 = Math.pow(calD1(data,av1),0.5)
    // b1 平均数
    let b1 = av1
    // 变异指标等于
    return a1/b1
}

标准分数

是将变量值与其算术均值的离差除以标准差后的测度值，也称标准化值或Z值。

// 计算分组数据的标准分差
const calZ = (data, av1,index) => {
    // data 是二维数组，[[10,5],[54,3]]
    // 每个元素的第一个数代表元素的组中值，第二个元素代表频数
    // index 为要计算标准分差的变量值在data中的索引
    const a1 = Math.pow(calD1(data, av1), 0.5); // 标准差，也称变异指标
    //假设要计算data中第i个变量值的标准分数
    let b1 = (data[index][0] - av1) / a1;
    return b1  // b1 即为data[index]对应的标准分差
}
// 计算未分组数据的标准分差
const calZ2 = (data, av1, index) => {
    // data 是一维数组，[10,20,30]
    // 每个元素的第一个数代表元素的组中值，第二个元素代表频数
    // index 为要计算标准分差的变量值在data中的索引
    const a1 = calAvStand(data, av1); // 标准差，也称变异指标
    //假设要计算data中第i个变量值的标准分数
    let b1 = (data[index] - av1) / a1;
    return b1; // b1 即为data[index]对应的标准分差
};

根据原始数据与标准分数的变换关系可知，将服从正态分布的数据标准化后。具有如下分布规律。

1. 约有68.27%的值分布在0加减1的范围内；
2. 约有95%的值分布在0加减1.96的范围内；
3. 约有95.45%的值分布在0加减2的范围内；
4. 约有99.73%的值分布在0加减3的范围内。

由标准差计算公式可知 随机变量I=平均值+标准分差*标准差，当满足正态分布时，一个值落在平均值减价一个标准差的概率为68.27%。

补充知识正态分布。

正态分布

对这块不太理解

// 正态分布
const calG = (x, av1, u) => {
    // x 随机变量
    // av1 平均数
    // u 标准差
    let res =
        (1 / (Math.pow(2 * Math.PI) * u)) *
        Math.pow(Math.E, -Math.pow(x - av1, 2) / (2 * Math.pow(u, 2)));
    return res;
};
// 标准正态分布
// 当平均值=0，标准差=0时
const calStanG = (x) => {
    let res =
        (1 / (Math.pow(2 * Math.PI) * u)) *
        Math.pow(Math.E, -Math.pow(x, 2) / 2);
    return res;
};

离群值

由前面的标准分差和正态分布的性质可知，一组变量值落在算术均值加减价3各标准差中的概率高达99.73%，因此将偏离这99.73%外的数据称为离群值。当将次标准化正态分布后，计算出标准分差，如果在[-3,3]的区间内，则说明该值不是离群值。

偏态及偏态系数

偏态指数据分布的不对称性特征，偏态系数是度量数据分布的不对称程度的测度值，用SK表示。

// 计算未分组数据偏态系数
const calcSk1 = (data,u,a) => {
    // data 一维数组[1,2,3]
    // u data的平均数
    // a data的标准差
    let av1 = 0;
    for (let i = 0; i < data.length; i++){
        av1 += Math.pow(data[i] - u, 3);
    }
    let SK = av1 / (Math.pow(a, 3) * data.length)
    return SK
}

// 计算分组数据的偏态系数
const calcSk2 = (data,u,a) => {
    // data 二维数组，[[10,2],[13,5]]，
    // 数组每个元素的第一个元素表示该组的组中值，第二个元素表示该组的频数
    // u data的平均数
    // a  data的标准差
    let av1 = 0;
    let b1 = 0;  // 总频数
    for (let i = 0; i < data.length; i++){
        av1 += Math.pow(data[i][0] - u, 3) * data[i][1];
        b1 += data[i][1];
    }

    let SK = av1 / (Math.pow(a, 3) * b1)
    return SK
}

上式中标准差和平均数可按照前面求平均数和标准差的公式按照数据类型求得。当SK=0为对称分布；SK>0右偏分布；SK<0左偏分布；SK>1||SK<-1高度偏态分布；SK>0.5&&SK<1||SK>-1&&SK<-0.5中等偏态分布；SK越接近0，偏斜程度越低。

峰态及峰态系数

指数据分布的平峰或尖峰形态。峰态系数是对数据分布峰度的测度值，用K表示。

// 计算未分组数据峰态系数
const calcK1 = (data, u, a) => {
    // data 一维数组，[1,2,3]
    // u 平均数
    // a 标准差
    let av1 = 0;
    for (let i = 0; i < data.length; i++){
        av1 += Math.pow(data[i]-u,4)
    }
    let K = av1 / (Math.pow(a, 4) * data.length) - 3
    return K
}
// 计算分组数据峰态系数
const calcK2 = (data, u, a) => {
    // data 二维数组，[[10,2],[13,5]]，
    // 数组每个元素的第一个元素表示该组的组中值，第二个元素表示该组的频数
    // u data的平均数
    // a  data的标准差
    let av1 = 0;
    let b1 = 0;
    for (let i = 0; i < data.length; i++){
        av1 += Math.pow(data[i][0] - u, 4) * data[i][1];
        b1 += data[i][1];
    }
    let K = av1 / (b1 * Math.pow(u, 4)) - 3;
    return K
}

峰态是与正态分布比较的，也就是说，如果一个数据是偏态分布，对它说峰态是没有意义的。
K=0扁平程度适中，K<0平峰分布；K>0尖峰分布。

时间序列的种类

1. 绝对数时间序列：将反映某一客观现象总规模或总水平的一系列绝对数按时间先后顺序排列而成的数列。它能够反映现象在不同时间绝对水平的变动过程。分为时期序列（反映某一时期内所累计发生的数值总量）和时点序列（反映的是某一时点或某一时刻所表现出来的数值总量）。
2. 相对数时间序列：将反映某一客观现象特征的相对数按时间顺序排列而成。它反映现象相对关系的发展变化情况，具体说明现象的结构、比例关系、比较关系、强度等的动态相对变化过程。
3. 平均数时间序列：将反映某一客观现象特征的平均数按时间顺序排列而成的时间序列。它反映现象一般水平在不同时间的发展变化。

绝对数时间序列被称为基础序列，相对数时间序列和平均数时间序列被称为派生序列。

时间序列数据的分析方法

有两种分析方法：传统（现在学习）,现代（后面学习，有AR,MA,ARMA,ARIMA）

时间序列构成因素

1. 长期趋势:指现象在相当长的一段时间内，沿某一方向持续变化的一种态势，用T表示。有线性趋势和非线性趋势
2. 季节变动：指在一年或更短的时期内，客观现象由于受到自然或社会因素等的影响而形成的具有某种固定规律的重复变动，用S表示。
3. 循环变动：指现象在持续若干年的时间内发生的涨落交替的周期变动，用C表示。
4. 不规则变动：指现象由于受偶然性因素影响而引起的无规律、不规则的变动，它包括随机变动和异常变动两种类型,用I表示。

时间序列数据分析的组合模型

补充：绝对数一定有计量单位（三种计量单位：实物单位，货币单位和矛盾单位），相对数可以简单理解为百分比或没有单位的数

1. 加法模型:y=T+C+S+I，y、T为绝对数，C、S、I分别为循环变动、季节变动、不规则变动因素对总变动影响的绝对数，前提条件是：各影响因素对时间序列数据的影响是彼此独立的。
2. 乘法模式:y=T*C*S*I，y、T为绝对数，C、S、I分别为循环变动、季节变动、不规则变动因素对总变动影响的相对数，前提条件是：各影响因素对时间序列数据的影响是彼此不独立的。

时间序列数据的图形分析

线图也称时序图：可以用于总体趋势和周期变化、异常点、升降转折点等；

时点序列的平均发展水平

计算假定：（1）上期期末时点数据即为本期期初时点数据；（2）相邻两个时点间现象的数量变动是均匀的。

1. 间隔不等间断时点序列

   // 计算间断不等间断点时点序列的平均发展水平
   // 采用加权算术平均值
   const calcY1 = (data) => {
       // data 是一个二维数组[[10,2],[20,4]]
       // 数组中每个元素的第一个元素表示该时刻的值，第二个元素表示相邻两个时点的间隔长度，
       // 计算公式为取相邻两个时点的值，计算简单算术平均值，然后乘以间隔长度，最后将全部结果相加，
       // 这个时候，相当于是在一个长度从t1,t2,...,tn的线段上在相邻线段间取一个点，这个点的值=(Yi+Y(i+1))/2,
       // 结果能取n-1个点。
       let av1 = 0;
       let b1 = 0;
       for (let i = 0; i < data.length-1; i++){
           av1 += (data[i][0]+data[i+1][0])/2*data[i][1]
           b1 += data[i][1];
       }
       let res = av1 / b1;
       return res
   }

2. 间隔相等时点序列

   // 计算间断不等间断点时点序列的平均发展水平
   // 采用加权算术平均值
   const calcY1 = (data) => {
       // data 是一个二维数组[[10,2],[20,4]]
       // 数组中每个元素的第一个元素表示该时刻的值，第二个元素表示相邻两个时点的间隔长度，
       // 计算公式为取相邻两个时点的值，计算简单算术平均值，然后乘以间隔长度，最后将全部结果相加，
       // 这个时候，相当于是在一个长度从t1,t2,...,tn的线段上在相邻线段间取一个点，这个点的值=(Yi+Y(i+1))/2,
       // 结果能取n-1个点。
       let av1 = 0;
       let b1 = 0;
       for (let i = 0; i < data.length-1; i++){
           av1 += (data[i][0]+data[i+1][0])/2*data[i][1]
           b1 += data[i][1];
       }
       let res = av1 / b1;
       return res
   }
   // 上面是间隔不等的计算公式，那么如果间隔相等，也就意味着data中每个元素的第二个元素相等，
   // 上面的av1= (Y1+Y2)/2*H+(Y2+Y3)/2*H，由于循环了data.length-1次,把data.length记为n
   // 则 av1 = (Y1/2+Y2+...+Yn/2)*H; b1=H*(n-1);
   // 则 res = av1/b1 = (Y1/2+Y2+...+Yn/2)/(n-1);

   上面的式子又称首末折半法

相对数时间序列的计算方法

计算公式：y=a/b,a代表分子时间序列的平均发展水平；b代表分母时间序列的平均发展水平。

发展速度

1. 环比发展速度计算方法：R = Yi/Y(i-1)；
2. 定基发展速度：R=Yi/Y0
3. 年距发展速度：R=报告期某月(季)发展水平/上年同月(季)发展水平

平均发展速度与平均增长速度

1. 用几何平均法计算平均发展速度

   // 水平法计算平均发展速度
   const calcR = (data) => {
       // data 一维数组[1,2,3,4];
       // 首先计算data的环比发展速度，然后相乘开data.length次根号
       // 环比发展速度等于Yi/Y(i-1);如果它们相乘，最后等于 Yn/Y0
       let res = Math.pow(data[data.length - 1] / data[0], 1 / data.length);
       return res
   }

2. 用方程法计算平均发展速度

   // 方程Y0*X+Y0*X*X+...Y0*X的n次方=Y1+Y2+Y3+...+Yn
   // 解x的N的方差解。

长期趋势

长期趋势类型分为:线性趋势（趋势是一条直线）；非线性趋势（不是线性趋势，有：二次曲线、增长曲线（指数曲线、修正指数曲线、龚珀兹曲线和罗吉斯蒂曲线等））

线性趋势的测定及预测

1. 移动平均法：通过对原时间序列发展水平进行一系列时平均数的方式，消除原时间序列中其它因素的影响，进而测定长期趋势的一种方法。
   确定步长K：（1）原时间序列无明显周期波动呈直线，步长确定为奇数；（2）时间序列为若干年的季度资料，K=4；（3）时间序列为若干年的月度资料，K=12，消除季节因素；（4）对以天为时间单位的时间序列，如果存在星期规律（周一效应或周末效应）则以星期内数据个数为移动步长。
   K为偶数，首尾各缺失K/2个数据，总缺失K个数据；K为奇数，首尾各缺失(K-1)/2个数据，总缺失K-1个数据。K越大，缺失数据越多。
   选用合适的K可以消除其它因素的影响，使得数据曲线变的平整，并不是K越大，数据曲线越平整。

   // 计算季节指数
   const calcM = (data) => {
       // data一维数组，[1,2,3,4，5,6,7,8];
       // 数组中每四个元素表示一年，每个元素表示每个季度的值，
       // 季节步长K=4；计算K项（K=4）的移正平均值。
       // K=4为偶数，缺失K项，首尾各缺失两相。
       // 在计算是，缺失项记为0；
       
   
   }

2. 线性趋势方程拟合法：是对原时间序列拟合线性方程，消除其它因素变动，从而揭示现象长期线性趋势规律的方法。一般形式：Yi=a+bTi，Yi为发展水平的趋势值，Ti为时间变量，通常取其编号，即1,2,3,...,n；a为截距，是Ti=0是Yi的初始值（即既定时间序列长期趋势的初始值）。b为趋势斜率，平均增长量逐期增长量之和/逐期增长量的个数，也等于累计增长量/时间序列项数-1。
   参数a和b通常按最小二乘法原理进行估计；该方法要求满足：各实际发展水平与其趋势值的离差平方和最小

   // (A1-Y1)*(A1-Y1)+(A2-Y2)*(A2-Y2)+···+(An-Yn)*(An-Yn)=min
   ```  
   ![线性拟合](/images/tu4.jpg)
   上面是求解`a`和`b`的过程。
   ```js
   // 求解线性拟合方程的a（截距）和b（斜率）
   const calcY = (data) => {
       // data是二维原始数组
       // 每个元素代表一个间断，每个元素数组里面的元素代表该时间段内各个小时间段的数据。
       // 比如[[1,2,3,4],[5,,6,7,8],[1,4,6,3]]
       // 这上面每个子元素包含的子元素个数需要相等，比如[1,2,3,4]表示第一年，[5,,6,7,8]表示第二年；
       // 1,2,3,4表示春夏秋冬四季。
   
       // 首先要对上面的数据重新排列，转为一维数组，确定t和y
       let t1 = 0; // 所有元素总和
       let tArr = []; // [[1,10],[2,20]] ,1表示ti,10表示yi，这里的yi是前面的总和
       let t22 = 0; // 保存的是新排序后T的总和
       for (let i = 0; i < data.length; i++) {
           for (let j = 0; j < data[i].length; j++) {
               let item = [0, 0];
               let newIndex = i * data[i].length + j + 1;
               item[0] = newIndex;
               item[1] = data[i][j];
               tArr.push(item);
               t1 += data[i][j];
               t22 += newIndex;
           }
       }
       // 到这里完成了data的重新排序和计算出了总的数值
       let j1 = 0; // 保存n倍的Ti*Yi的总和
       let j2 = 0; // Ti的和
       let j3 = 0; // Yi的和
       let j4 = 0; // 保存所有Ti*Ti的和
       for (let k = 0; k < tArr.length; k++) {
           j1 += tArr.length * (tArr[k][0] * tArr[k][1]);
           j2 += tArr[k][0];
           j3 += tArr[k][1];
           j4 += Math.pow(tArr[k][0], 2);
       }
       let b = (j1 - j2 * j3) / (tArr.length * j4 - Math.pow(j2, 2));
       // 计算Y和T的平均数
       let y1 = t1 / tArr.length;
       let a = y1 - (b * t22) / tArr.length;
       return [a, b]; // a截距，b斜率
   };

二次曲线

Yi = a + b*Ti+c*Ti*Ti;指逐期增长量的逐期增长量

指数曲线

// const y = a*Math.pow(b,Ti); // Ti中的i=1，2，3，4...n
// b>1增长率增加
// b<1 增长率随Ti的增加减少
// a>0,b<1 趋势y逐渐减少到以0为极限。

从上面可以看出如果对(Yi-y)*(Yi-y)求对a和b的偏导数非常困难，因此可以两边同时化为以10为底的对数。下面尝试求解。

修正指数曲线

在一般指数曲线的基础上增加一个常数K，即为修正曲线。

// const y = K + a*Math.pow(b,Ti);

这个K可以通过三和法求解

// 三和法求解修正曲线的a,b,K值
const calcK = (n, a, b, S1, S2, S3) => {
    
    // S1是数据中n=1,2,...n/3对应Yn的值的和。
    // S2 是数据中n/3+1到2n/3对应的Yn的值的和
    // S3 是数据中2n/3+1到n对应的Yn的值的和
    // a，b是根据指数曲线的定义结合最小二乘法求得的系数；
    // n 是数据的总个数
    let b = Math.pow((S3 - S2) / (S2 - S1), 3 / n)
    let a = ((S2 - S1) * (b - 1)) / (b * Math.pow(Math.pow(b, n / 3) - 1,2)); 
    let K = (S1 - (a * b * (Math.pow(b, n/3) - 1) / (b - 1))) *3/n
    return [a, b, K];
}

龚珀兹曲线

Yi=K*abTi,abTi是a的b的Ti次方，可以化成对数会变成修正指数曲线。

罗吉斯蒂曲线

Yi = 1/(K+a*bTi),bTi是b的Ti次方。取倒数为修正指数曲线。

三和法

将时间序列分为项数相等的三个部分，分别对每部分的发展水平求和，根据这三个和与模型参数的关系求解参数的估计值。

趋势剔除法

有两种方法：移动平均趋势剔除法（采用平均法求得）；趋势方程剔除法（采用趋势方程拟合法确定）。

移动平均趋势剔除法

1. 计算移动平均值：Yi=Ti*Si*Ci*Ii，移动平均值包含长期趋势和循环变动，即Mi=Ti*Ci，如果不含循环变动，Mi=Ti。
2. 剔除趋势成分（趋势-循环成分）：
3. 消除不规则变动I：
4. 计算跳转季节指数S：

   // 首先计算每个季度的长期趋势Mi，
   // 再计算 Yi/Mi=Si*Ii
   // 这个时候计算出来的Si*Ii会缺失K项，在使用程序进行加减计算时，可以把这些缺失值标记为0；
   // 算出每年的Mi平均值，再相加；算出同季度的平均值之和；
   // 用同季度平均之和除以总的平均值，即为调整季节指数

5. 消除季节影响量=季节值除以季节指数。
6. 循环变动值：（1）如果季节变动不存在，此时短期的不规则变动趋于消失，则Yi=Ti*Ci，Ti长期趋势值，Ci循环变动值。基于次，可求得Ci=Yi/Ti。Yi/(Ti*Si)=Ci*Ii，Yi为消除季节影响的值（Yi=真实值/季节指数），Ti*Si为趋势值（季节变动不存在，Si=1），得到Ci*Ii，然后进行移动平均法，消除不规则变动，即可得循环变动系数。

统计指数分析

1. 广义指数：泛指相对数，如比较相对数、发展速度、计划完成相对数等。
2. 狭义指数：一种特殊相对数，它反映复杂现象总体某一方面数量特征综合变动方向和变动程度的相对数。相对性、综合性和平均性，动态指数和静态指数（静态指数包括空间指数和计划完成指数）
3. 个体指数：Kq=Q1/Q0,Kq个体数量指数,Q1指报告期数量，Q0指基期数量，Kp=P1/P0，Kp个体质量指数，P1指报告期质量，P0指基期质量。
4. 总指数：
5. 类指数CPI

拉氏指数

计算数量指数

// 0指基期
// Iq = Q1P0/Q0P0
// Ip = Q0P1/Q0/P0

// 计算拉氏数量指数
// 计算方法：Q1P0/Q0P0
const calcQ = (data) => {
    // data是二维数组，[[10,20,30,35]]
    // 每个数组中的元素中的元素依次表示：Q0,Q1,P0,P1,即基期数量、报告期数量、基期质量、报告质量。
    // 分别计算Q0P0,Q1P0,Q1P1
    let res1 = [];
    for (let i = 0; i < data.length; i++){
        let item = [];
        item.push(data[0]*data[2],data[1]*data[2],data[1]*data[3])
        res1.push(item);
    } 
    // 计算Q1P0的和；即res1[i][1]
    let res2 = 0;
    // 计算Q0P0的和：即res1[i][0]
    let res3 = 0;
    for (let j = 0; j < res1.length; j++){
        res2 += res1[j][1];
        res3 += res1[j][0];
    }
    return res2 / res3;
}

派氏指数

计算质量指数

// 1指报告期
// Iq=Q1P1/Q0P1
// Ip=Q1P1/Q1P0
// 计算派氏质量指数
// 计算方法：Q1P1/Q1P0
const calcQ = (data) => {
    // data是二维数组，[[10,20,30,35]]
    // 每个数组中的元素中的元素依次表示：Q0,Q1,P0,P1,即基期数量、报告期数量、基期质量、报告质量。
    // 分别计算Q0P0,Q1P0,Q1P1
    let res1 = [];
    for (let i = 0; i < data.length; i++){
        let item = [];
        item.push(data[0]*data[2],data[1]*data[2],data[1]*data[3])
        res1.push(item);
    } 
    // 计算Q1P1的和；即res1[i][2]
    let res2 = 0;
    // 计算Q1P0的和：即res1[i][1]
    let res3 = 0;
    for (let j = 0; j < res1.length; j++){
        res2 += res1[j][2];
        res3 += res1[j][1];
    }
    return res2 / res3;
}

平均指数

加权算术平均、加权调和平均和几何平均

各种回归模型参数求解

前面学习了部分回归模型的求解，现在系统性的归纳。

修正指数曲线

y=K + a*Math.pow(b,x);

// 求解
// 三和法求解修正曲线的a,b,K值
const calcK = (n, a, b, S1, S2, S3) => {
    
    // S1是数据中n=1,2,...n/3对应Yn的值的和。
    // S2 是数据中n/3+1到2n/3对应的Yn的值的和
    // S3 是数据中2n/3+1到n对应的Yn的值的和
    // a，b是根据指数曲线的定义结合最小二乘法求得的系数；
    // n 是数据的总个数
    let b = Math.pow((S3 - S2) / (S2 - S1), 3 / n)
    let a = ((S2 - S1) * (b - 1)) / (b * Math.pow(Math.pow(b, n / 3) - 1,2)); 
    let K = (S1 - (a * b * (Math.pow(b, n/3) - 1) / (b - 1))) *3/n
    return [a, b, K];
}

各类均值计算方法

极大值对算术均值影响较大，极小值对调和均值的影响最大，极端值对几何均值的影响较小。

注意事项：计算和应用均值应注意总体同质性；用组均值来补充说明总均值；用频数分布补充说明均值。

1. 各种时间序列的计算。时间序列：绝对数时间序列，相对数时间序列，平均数时间序列。

   // 根据组距分组数据确定众数
   export const calcMax = (data: any[]) => {
       // const data2 = [
       //     [10, 20, 30],
       //     [20, 50, 10],
       //     [50, 75, 45],
       // ]; // [10,20,30]，依次表示下组限，上组限，频数
       try {
           // data2 是一个不等距分组数据。
           // 不等距：众数是频数密度最大的组，频数密度=频数➗组距
           // 等距：组距相等，就等于频数最大的组。
           if (data.length <= 1) {
               return data[0][0] + (data[0][1] - data[0][0]) / 2;
           }
           let maxIndex = 0;
           for (let i = 1; i < data.length; i++) {
               let f1 = data[i][2] / (data[i][1] - data[i][0]);
               let f2 =
                   data[maxIndex][2] / (data[maxIndex][1] - data[maxIndex][0]);
               if (f1 > f2) {
                   maxIndex = i;
               }
           }
           let Lm = data[maxIndex][0]; // 下限
           let Fm = data[maxIndex][2]; // 众数所在组的频数；
           let Fml = data?.[maxIndex - 1]?.[2] || 0; // 众数所在组前一个组的频数
           let Fmu = data?.[maxIndex + 1]?.[2] || 0; /// 众数所在组后一个组的频数。
           let Dfm = data[maxIndex][1] - data[maxIndex][0]; // 众数所在组的组距
           return Lm + ((Fm - Fml) / (2 * Fm - Fml - Fmu)) * Dfm;
       } catch (error) {
           return "-";
       }
   };

2. 中位数确定，假设数据总个数为N
   顺序数据：也就是所使用的数据已排序，中位数=(N+1)/2
   数值数据：未分组数据和单变量值分解数据（中位数=(N+1)/2）；组距分组数据（中位数=N/2）
   顺序数据一般为单变量值分组数据

   export const calcMe = (data: any[]) => {
       // 计算数学数据中位数。记住先排序。
       // const data=[["非常不满意",5],["不满意",18],["一般",35],["满意",67],["非常满意",25]]
       try {
           let u1 = 0; // 前n项和
           let u = []; // 记录向上累计频数
           for (let i = 0; i < data.length; i++) {
               u1 += data[i][1];
               u.push(u1);
           }
           let M1 = (u1 + 1) / 2; // 中位数的位置。
           // 通过在向上累计的频数数组u中，找出该值的index；
           let index = -1;
           for (let i = 1; i < u.length; i++) {
               if (M1 < u[i] && M1 > u[i - 1]) {
                   index = i;
                   break;
               }
           }
           if (index === -1) {
               index = 0;
           }
           return data[index][0];
       } catch (error) {
           return "-";
       }
   };
   
   // 计算未分组数据和单变量值分组数据的中位数的值
   export const calcMe2 = (data: any[]) => {
       // data =[1,2,3,4,5,6,7];
       try {
           data.sort((a, b) => a - b); // 对原数据从小到大排序。
           let odd = data.length % 2;
           let Me = 0;
           if (odd === 0) {
               // 偶数
               let oddIndex = Math.floor(data.length / 2);
               Me = (data[oddIndex] + data[oddIndex + 1]) / 2;
           } else {
               Me = data[(data.length + 1) / 2];
           }
           return Me;
       } catch (error) {
           return "-";
       }
   };
   
   // 组距分组数据计算中位数的值
   export const calcMe3 = (data: any[]) => {
       // const data2 = [
       //     [10, 20, 30],
       //     [20, 50, 10],
       //     [50, 75, 45],
       // ]; // [10,20,30]，依次表示下组限，上组限，频数
       // 首先计算中位数所在的组 N/2，N为总频数
       let m1 = []; // 记录向上累加的频数。
       let m2 = 0; // 记录前i项的频数和；
       for (let i = 0; i < data.length; i++) {
           m2 += data[i];
           m1.push(m2);
       }
       let m3 = m2 / 2; // 此时的m2为总频数，也就是N，则m3为中位数位置数值
       // 通过在向上累计的频数数组u中，找出该值的index；
       let index = -1;
       for (let i = 1; i < m1.length; i++) {
           if (m3 < m1[i] && m3 > m1[i - 1]) {
               index = i;
               break;
           }
       }
       if (index === -1) {
           index = 0;
       }
       // index 为中位数所在组的索引
       let Lm = data[index][0]; // 下限
       let Sml = m1?.[index - 1] || 0; // 中位数所在组之前的所有组的频数之和。
       let C = m2 / 2; // 总频数的一半；
       let Lmf = data[index][2]; // 中位数所在组的频数
       let Lmd = data[index][1] - data[index][0]; // 中位数所在组的组距
       let Me = Lm + ((C - Sml) / Lmf) * Lmd;
       return Me;
   };

3. 四分位计算。未分组数据：下四分位=(N+1)/4;上四分位=3*(N+1)/4，如果N+1不能被4整除，此时采用加权平均值求中文数的值。

   export const calcMf = (data: any[]) => {
       // data =[1,2,3,4,5,6,7];
       data.sort((a, b) => a - b); // 先排序
       let lf = 0;
       let lf1 = (data.length + 1) % 4;
       if (lf1 === 0) {
           // 说明可以整除
           lf = data[lf1];
       } else {
           // 不能整除
           let lf2 = (data.length + 1) / 4; // (N+1)/4的值，是一个浮点数
           let lf2Int = Math.floor(lf2); // 向下取整数部分
           let lf2f = lf2 - lf2Int; // 小数部分。
           // 接下来求数组中的第lf2Int和lf2Int+1个数，即索引=lf2Int-1,lf2Int;
           // lf2f表示lf2距离第lf2Int个数的距离为lf2f，lf2f越大，表示距离越远，
           // 也就意味着权重越小，因此第lf2Int个数对应的权重应该为 1- lf2f
           let lv = data[lf2Int - 1] * (1 - lf2f); // 中位数位置左侧的数
           let lr = data[lf2Int] * lf2f; // 中位数右侧位置的数。
           lf = (lv + lr) / (1 - lf2f + lf2f);
       }
       // 同理也可求得上四分位
       return lf;
   };
   
   // 分组数据：下四分位=N/4;上四分位=3*N/4
   // 分组四分位与中位数解法类似。不再赘述
   

4. 均值计算

   // 未分组数据算术均值,又称简单算术平均值
   export const calcVAv1 = (data: any[]) => {
       let res = 0;
       for (let i = 0; i < data.length; i++){
           res+=data[i]
       }
       return res / data.length;
   }
   // 分组数据计算算术平均值，加权算术平均值，频数称为权数，频率称为实质权数。
   // 如果是组距分组，取组中值为该组的变量值。
   export const calcVAv2 = (data: any[],t:"1"|"2") => {
       // t："1"表示单变量值分组，"2"表示组距分组
       //data=[[1,2,3],[5,6,7]] 或者 [[1,2],[3,4]]
       // 如果是组距分组，[1,2,3]依次表示下限、上限和频数
       // 如果是单变量值分组，[1,2]依次表示单变量值、频数。
       let f1 = 0; // 总频数
       let c1 = 0; // 每个组的变量值与其频数的乘积，最后再相加的总和。
       for (let i = 0; i < data.length; i++){
       
           if (t === "1") {
               c1 += data[i][0] * data[i][1];
               f1 += data[i][1];
           } else {
               let v = (data[i][0] + data[i][1]) / 2
               c1 += v*data[i][2]
               f1 += data[i][2];
           }
       }
       if (f1 !== 0) {
           return c1 / f1;
       }
       return 0
   }
   
   // 相对数和平均数的算术均值计算
   // 选择适当的分子或分母数据作为权数。
   
   // 调和均值，又称倒数均值
   // 是各变量值倒数的算术均值的倒数。
   // 简单调和均值计算
   export const calcSimVAv1 = (data: any[]) => {
       // data =[1,2,3,4,5,6,7];
       let f1 = 0; // 倒数和
       for (let i = 0; i < data.length; i++){
           f1 += (1 / data[i]);
       }
       let f2 = f1 / data.length; // 倒数和的算术平均值
       return 1 / f2; // 倒数和的算术平均值的倒数
   }
   // 加权调和均值
   export const calcSimVAv2 = (data: any[], t: "1" | "2") => {
       // t "1"表示单变量分组数据，"2"表示组距分组数据。
       //data=[[1,2,3],[5,6,7]] 或者 [[1,2],[3,4]]
       // 如果是组距分组，[1,2,3]依次表示下限、上限和频数
       // 如果是单变量值分组，[1,2]依次表示单变量值、频数。
       let f1 = 0; // 总频数
       let c1 = 0; // 每个组的变量值与其频数的乘积，最后再相加的总和。
       for (let i = 0; i < data.length; i++) {
           if (t === "1") {
               c1 += 1/data[i][0] * data[i][1];
               f1 += data[i][1];
           } else {
               let v = (data[i][0] + data[i][1]) / 2;
               c1 += 1/v * data[i][2];
               f1 += data[i][2];
           }
       }
       if (c1 !== 0) {
           return f1/c1;
       }
       return 0;
   }
   // 调和均值是算术均值的另一种算法

5. 几何均值。如果被平均的变量值中有一个为零，则不能计算几何均值。 几何均值适用于各变量值存在连乘积关系的场合，常用于平均速度的计算。

   // 简单几何均值
   export const calcSimGAv1 = (data: any[]) => {
       // data =[1,2,3,4,5,6,7];
       let f1 = 1;
       for (let i = 0; i < data.length; i++){
           f1 *= f1 * data[i];
       }
       return Math.pow(f1, 1 / data.length);
   }
   
   // 加权算术均值
   export const calcSimGAv2 = (data: any[], t: "1" | "2") => {
       // t "1"表示单变量分组数据，"2"表示组距分组数据。
       //data=[[1,2,3],[5,6,7]] 或者 [[1,2],[3,4]]
       // 如果是组距分组，[1,2,3]依次表示下限、上限和频数
       // 如果是单变量值分组，[1,2]依次表示单变量值、频数。
       let f1 = 0; // 总频数
       let c1 = 1; // 乘积
       for (let i = 0; i < data.length; i++){
           if (t === "1") {
               c1 *= Math.pow(data[0],data[1])
               f1 += data[i][1];
           } else {
               let v = (data[i][0] + data[i][1]) / 2;
               c1 *= Math.pow(v,data[i][2])
               f1 += data[i][2];
           }
       }
       return Math.pow(c1, f1);
   
   }

6. 异众比率:非众数值的频数站全部变量值总频数的比重。异众比率的作用是衡量众数对一组变量值的代表性程度。

   export const calcMax1 = (data: any[]) => {
       // const data2 = [
       //     [10, 20, 30],
       //     [20, 50, 10],
       //     [50, 75, 45],
       // ]; // [10,20,30]，依次表示下组限，上组限，频数
       try {
           // data2 是一个不等距分组数据。
           // 不等距：众数是频数密度最大的组，频数密度=频数➗组距
           // 等距：组距相等，就等于频数最大的组。
           
           let maxIndex = 0;
           let c = 0;// 总频数
           for (let i = 1; i < data.length; i++) {
               let f1 = data[i][2] / (data[i][1] - data[i][0]);
               let f2 =
                   data[maxIndex][2] / (data[maxIndex][1] - data[maxIndex][0]);
               if (f1 > f2) {
                   maxIndex = i;
               }
               c += data[i][2];
           }
           let f3 = c - data[maxIndex][2];// 非众数的频数
           return f3 / c;
       } catch (error) {
           return "-";
       }
   }

7. 根据组中值和频数计算加权平均值和比重；计算加权标准差

   // data 二维数组[[1,2],[3,4]],1表示组中值，2表示频数
   const calcAver = (data: any[]) => {
       let f1 = 0; // 总频数
       let f2 = 0; // 加权总和
       for (let i = 0; i < data.length; i++) {
           f1 += data[i][1];
           f2 += data[i][0] * data[i][1];
       }
       let av1 = f2 / f1; // 加权平均值
       let px1 = []; // 是每个组的频率，即比重
       for (let j = 0; j < data.length; j++) {
           let item = data[j][1] / f1;
           px1.push(item);
       }
       return [av1, px1];
   };
   // 计算加权标准差
   const calD1 = (data,av1) => {
       // data 是二维数组，[[10,5],[54,3]]
       // 每个元素的第一个数代表元素的组中值，第二个元素代表频数
       let da1 = 0;  // 每个组的平方差乘以频数，最后将所有组相加的总和
       let db1 = 0;  // 总频数
       for (let i = 0; i < data.length; i++){
           let item = Math.pow(data[i][0] - av1, 2) * data[i][1];
           da1 += item;
           db1 += data[i][1];
       }
       let s1 = da1 / db1;
   
       return Math.pow(s1,0.5);
   }
   
   // 下面两个式子中，f1为各组的频率，即上面的px1，av1为加权标准差，即上面的av1
   // d1是加权标准差，即calD1的返回值,
   // 计算偏态系数
   const calcSK = (data: any[],f1:any[],av1,d1) => {
       let a2 = 0; // (data[i]-av1)*比重的和
       for (let i = 0; i < data.length; i++){
           let item = Math.pow(data[i][0] - av1, 3) * f1[i];
           a2 += item;
       }
       let sk = a2 / Math.pow(d1, 3)
       return sk;
   }
   
   // 计算峰态系数
   const calcK = (data: any[], f1: any[], av1, d1) => {
       let a2 = 0; // (data[i]-av1)*比重的和
       for (let i = 0; i < data.length; i++) {
           let item = Math.pow(data[i][0] - av1, 4) * f1[i];
           a2 += item;
       }
       let sk = a2 / Math.pow(d1, 4);
       return sk-3;
   }

8. 计算线性拟合方程

   // 计算线性拟合方程
   // 当时间序列发展水平的逐期增长量相等或大致相同，可以计算线性趋势方差。
   export const calcLinear = (data: any[]) => {
       // [[1,3],[2,6],[3,9]];
       // 先将data的频数转为一维数组。
       let a1 = [];
       let x = [];
       for (let i = 0; i < data.length; i++){
           a1.push(data[i][1]);
           x.push(i + 1);
       }
       // 先假设该数据满足线性趋势方程的求解要求
       // y=a-bx,求a和b
       let n1 = 0; // 记录ti*yi的和
       let t1 = 0; // 记录ti的和
       let y1 = 0; // 记录yi的和
       let t2 = 0; // 记录ti*ti的和
       for (let j = 0; j < a1.length; j++){
           n1 += a1[j] * x[j];
           t1 += x[j];
           y1 += a1[j];
           t2 += x[j] * x[j];
       }
       let b = (data.length * n1 - t1 * y1) / (data.length * t2 - Math.pow(t1, 2))
       let a = y1 / data.length - b * t1 / data.length
       // 到这里计算出了截距a和斜率b
       // 为了验证该数据是否符合线性趋势，需要计算决定系数R2
       let y2 = []; // 线性拟合对应的预期值
       for (let i = 0; i < data.length; i++){
           let item = a + b * (i + 1);
           y2.push(item);
       }
       let ya = y1 / data.length; // 平均值
       let r1 = 0;  // 记录预期值与平均值之差的平方和
       let r2 = 0; // 记录实际值与平均值之差的平方和
       for (let k = 0; k < data.length; k++){
           r1 += Math.pow(y2[k] - ya, 2);
           r2 += Math.pow(a1[k]-ya,2)
       }
       let rs = r1 / r2;
       // rs越大，说明xi对yi的解释能力越好。
       return [a, b,rs]; 
   }

9. 计算二次曲线

   // 计算二次曲线
   // 首先要计算逐期增长量的逐期增长量，也就是二次差
   // 只有二次差大致相同，才可以使用二次曲线趋势方程。
   // const testData = [[1,2],[3,4],[6,7]] 1表示组中值，2表示
   export const calcScircal = (data: any[]) => {
       // yi = a+bti+cti*ti
       let a1 = [];
       let x = [];
       for (let i = 0; i < data.length; i++) {
           a1.push(data[i][1]);
           x.push(i + 1);
       }
       // 计算yi的和、ti的和、ti方的和、ti*yi的和、ti三次方的和
       // ti四次方的和、ti方乘以yi的和。
       let y1 = 0; // yi的和
       let t1 = 0; //ti的和
       let t2 = 0; // ti方的和
       let t3 = 0; // ti三次方的和
       let t4 = 0;  // ti四次方的和
       let ty = 0; // ti*yi的和
       let t2y = 0; // ti方乘以yi的和
       for (let i = 0; i < a1.length; i++){
           y1 += a1[i];
           t1 += x[i];
           t2 += Math.pow(x[i], 2)
           t3 += Math.pow(x[i], 3)
           t4 += Math.pow(x[i], 4)
           ty += a1[i] * x[i]
           t2y += Math.pow(x[i],2)*a1[i]
       }
   
       // 计算a,b,c的公式，n为数据个数
       // y1= na+bt1+ct2
       // ty = at1+bt2+ct3 
       // t2y = at2+bt3+ct4
       // 可以看作一个非齐次线性方程组求解a,b,c
       // 先构造方程。
       // let i1 = [data.length, t1, t2, y1];
       // let i2 = [t1, t2, t3, ty];
       // let i3 = [t2, t3, t4, t2y];
       // let ju = [i1, i2, i3];
       // 
       const matrix = [
           [data.length, t1, t2, y1],
           [t1, t2, t3, ty],
           [t2, t3, t4, t2y],
           [i1, i2, i3],
       ];
       const params = fmtMatrix(matrix)
       // params 是一个阶梯矩阵，如果有唯一解，则形如
       // [[A,B,C,y1],[0,D,E,y2],[0,0,F,y3]]
       // 则，可以得到以下方程：
       // Aa+Bb+Cc=y1
       // Db+Ec=y2
       // Fc=y3
       // 则 c=y3/F
       // 带入上面两个方程，可以依次求得a，b
   }
   
   
   // [
   //     [1, 2, 3, 5],
   //     [2, 6, 7, 9],
   //     [3, 10, 6, 8],
   // ];
   // 尝试写出矩阵的初等变换
   export const fmtMatrix = (data: any[]) => {
       // let res2 = [data[0]]
       let res = [...data];
       // 第一步 将第一列元素做初等变换，
       for (let k = 1; k < res.length; k++){
           // res = JSON.parse(JSON.stringify(res));
           // k=1,
           let item1 = res[k-1]; //[1, 6, 7, 9]
           for (let l = k; l < res.length; l++) {
               //l=1;
               let a1 = [];
               let add1 = res[l][k-1] / item1[k - 1]; // res[k-1]=[1, 2, 3, 5]
               // console.log(add1, l,k);
               // console.log(res[k]);
               for (let j = 0; j < res[k].length; j++) {
                   let item2 = item1[j] * add1;
                   a1.push(res[l][j] - item2);
                   
               }
               // console.log(a1, l);
               res[l] = a1;
           }
       }
       return res
   }

机器学习掌握的知识

数学基础：机器学习涉及到很多数学知识，如线性代数、微积分、概率论和统计学等。这些数学知识是理解和应用机器学习算法的基础。

编程基础：机器学习需要掌握至少一种编程语言，如Python、Java或C++等，并熟悉相关的编程工具和开发环境。此外，掌握一些数据处理和可视化工具，如Numpy、Pandas和Matplotlib等也是必要的。

数据结构和算法：机器学习算法涉及到许多数据结构和算法，如树、图、排序、搜索和聚类等。因此，掌握这些数据结构和算法是必要的。

机器学习算法：机器学习需要掌握一些基本的机器学习算法，如线性回归、逻辑回归、决策树、支持向量机和神经网络等。此外，了解不同的算法适用于不同的问题类型和数据类型也很重要。

数据挖掘和特征工程：机器学习需要掌握一些数据挖掘和特征工程技术，如数据清洗、特征提取和特征选择等。这些技术可以提高模型的性能和预测准确率。