皮尔森（pearson）相关系数

 

1. 相关系数：

考察两个事物（在数据里我们称之为变量）之间的相关程度。如果有两个变量：X、Y，最终计算出的相关系数的含义可以有如下理解：

(1)、当相关系数为0时，X和Y两变量无关系。

(2)、当X的值增大（减小），Y值增大（减小），两个变量为正相关，相关系数在0.00与1.00之间。

(3)、当X的值增大（减小），Y值减小（增大），两个变量为负相关，相关系数在-1.00与0.00之间。

相关系数的绝对值越大，相关性越强，相关系数越接近于1或-1，相关度越强，相关系数越接近于0，相关度越弱。

 

通常情况下通过以下取值范围判断变量的相关强度：

相关系数     0.8-1.0     极强相关

                 0.6-0.8     强相关

                 0.4-0.6     中等程度相关

                 0.2-0.4     弱相关

                 0.0-0.2     极弱相关或无相关

 

 2. 皮尔森(pearson)相关系数

 

    首先放上公式：



公式定义为： 两个连续变量(X,Y)的pearson相关性系数(Px,y)等于它们之间的协方差cov(X,Y)除以它们各自标准差的乘积(σX,σY)。系数的取值总是在-1.0到1.0之间，接近0的变量被成为无相关性，接近1或者-1被称为具有强相关性。

 

3. 根据以上公式，python3实现代码：

def pearson(vector1, vector2):

    n = len(vector1)

    #simple sums

    sum1 = sum(float(vector1[i]) for i in range(n))

    sum2 = sum(float(vector2[i]) for i in range(n))

    #sum up the squares

    sum1_pow = sum([pow(v, 2.0) for v in vector1])

    sum2_pow = sum([pow(v, 2.0) for v in vector2])

    #sum up the products

    p_sum = sum([vector1[i]*vector2[i] for i in range(n)])

    #分子num，分母den

    num = p_sum - (sum1*sum2/n)

    den = math.sqrt((sum1_pow-pow(sum1, 2)/n)*(sum2_pow-pow(sum2, 2)/n))

    if den == 0:

        return 0.0

    return num/den

 

现在，用两个向量测试一下：

vector1 = [2,7,18,88,157，90,177,570]

vector2 = [3,5,15,90,180, 88,160,580]

运行结果为0.998，可见这两组数是高度正相关的。

拉格朗日插值
数学原理
此处的拉格朗日插值均为多项式插值，固定下节点，多项式立刻确定下来。

n+1个互异节点满足插值条件的n次拉格朗日插值多项式为：






代码实现
算法实现过程：

1.获取节点个数

2.将节点的x和y存入两个数组中

3.在进行拉格朗日插值中，利用两层循环，外循环累加每一项lk(x)的的值，内循环计算各项lk(x)的值（i!=j时进行累乘）
#include<iostream>
#include<stdlib.h>
using namespace std;

float x[10];
float y[10];
int count;

void load_data()
{
	cout<<"the count is";
	cin>>count;
	for(int i=0;i<count;i++)
	{
		cin>>x[i]>>y[i];
		cout<<"\n";
	}
}

void print_data()
{
	for(int i=0;i<count;i++)
	{
		cout<<"x is "<<x[i]<<" y is "<<y[i]<<'\n';
	}
}


float Lagrange_interpolation(float value_x)
{
	float sum_all=0;
	float sum_single;
	for (int i=0;i<count;i++)
	{
		sum_single=y[i];
		for(int j=0;j<count;j++)
		{
			if(i==j)
				continue;
			else
			{
				sum_single*=(value_x-x[j])/(x[i]-x[j]);
			}
		}
		//cout<<"the sum_single is "<<sum_single<<endl;
		sum_all+=sum_single;
	}
	return sum_all;
}

void main()
{
	float value_x;
	float result;
	load_data();
	print_data();
	cout<<"please input the value_x ";
	cin>>value_x;
	result=Lagrange_interpolation(value_x);
	cout<<"the output is "<<result;
	system("pause");
}

埃特金插值
数学原理
采用逐次线性插值的方法，可以灵活地增加插值节点，且具有所谓的“承袭性”



上图即为原理图，每一次新增的插值都是采用线性插值，即取两个节点。

举例：



得到的表达式将与拉格朗日插值相同。

特点：

1.将一个高次插值过程归结为线性插值的多次重复

2.埃特金插值表中的每个数据均可视为差值结果；这些数据的一致程度即可判断差值结果的精度

3.可以逐行生成插值表，每做一步便检查一下计算结果的精度，如不满足精度，则增加一个节点再算，直到满足精度为止

4.在插值节点较多的情况下，可以降低插值次数
代码实现

1.建立了数组node用于存放节点的x坐标，建立数组result用于存放不同阶数的插值，为一个三角矩阵

2.数组result的存放格式为：行代表的是插值的阶数，列代表的是对应阶数的不同的插值项

3.具体的计算逻辑见Aitken_interpolation(float x)，主要是找前一阶的插值（首项以及对应项），前一阶的插值找到后就可以找到对应的节点值
#include <iostream>
#include <stdlib.h>
using namespace std;

int count;
float result[10][10];
float node[10];

void Load_data()
{
	cout<<"please input the count ";
	cin>>count;

	cout<<"input the node and result"<<endl;
	for(int i=0;i<count;i++)
	{
		cin>>node[i]>>result[0][i];
		cout<<endl;
	}
}

void Print_result()
{
	for (int i=0;i<count;i++)
	{
		for (int j=0;j<count;j++)
		{
			cout<<result[i][j]<<" ";
		}
		cout<<endl;
	}
}

void Aitken_interpolation(float x)
{
	for (int i=1;i<count;i++)
	{
		for (int j=i;j<count;j++)
		{
			result[i][j]=result[i-1][j]*(x-node[i-1])/(node[j]-node[i-1])+result[i-1][i-1]*(x-node[j])/(node[i-1]-node[j]);
		}
	}
}

void main()
{
	float x;
	Load_data();
	cout<<"please input the value_x ";
	cin>>x;
	Aitken_interpolation(x);
	Print_result();
	system("pause");
}

PS：如何实现尾部插入不需全部重新计算？
牛顿插值
数学原理
差商的定义：

一阶：

二阶：



n阶差商：



差商表：



建立差商表后，利用差商的定义式进行递推：





最后留出余项：



可以发现，实际用到的各阶差商值为差商表中的对角线项。



代码实现

1.建立两个数组，数组node代表节点的x值，二维数组quotient_table代表的是各阶的差商的表

2.差商表的每一行代表的是阶数，每一列代表的是同一阶数的不同项的差商

3.在计算差商时，需要找到上一阶的差商值（即上一阶的同列以及上一列），也要找到节点（一个节点的索引为该列序号，另一个节点索引应为该列序号减去阶数），具体见Build_quotient_table()

4.实现牛顿插值时，使用temp_x作为中间变量对(x-xi)的累乘进行保存，减少计算次数
#include <iostream>
#include <stdlib.h>
using namespace std;

int count;
float quotient_table[10][10];
float node[10];

void Load_Data()
{
	cout<<"please input the count ";
	cin>>count;
	cout<<"\nplease input the node and zero order of quotient"<<endl;
	for (int i=0;i<count;i++)
	{
		cin>>node[i]>>quotient_table[0][i];
		cout<<endl;
	}
}

void Print_quotient_table()
{
	for (int i=0;i<count;i++)
	{
		for (int j=0;j<count;j++)
		{
			cout<<quotient_table[i][j]<<" ";
		}
		cout<<endl;
	}
}

/*
 *@name Build_quotient_table：建立差商表
 *@return none
*/
void Build_quotient_table()
{
	for (int i=1;i<count;i++)
	{
		for (int j=i;j<count;j++)
		{
			//二维数组每一行i对应的是i阶差商，每一列j对应的是在该阶差商中的不同项之间的差商
			quotient_table[i][j]=(quotient_table[i-1][j]-quotient_table[i-1][j-1])/(node[j]-node[j-i]);
		}
	}
}

/*
 *@name Newton_interpolation：利用牛顿插值进行计算
 *@param x：变量x
 *@return：牛顿插值得到的结果
*/
float Newton_interpolation(float x)
{
	float sum=0;
	float temp_x=1;
	for (int i=0;i<count;i++)
	{
		sum+=temp_x*quotient_table[i][i];
		temp_x*=(x-node[i]);
	}
	return sum;
}

void main()
{
	Load_Data();
	Build_quotient_table();
	Print_quotient_table();
	cout<<"the result is "<<Newton_interpolation(0.596)<<endl;
	system("pause");
}

可以参考一下别人的代码（没有通过数组去保存，直接迭代）：https://blog.csdn.net/weixin_43242836/article/details/90813652

Java 编写一个类DengCha，该类含有成员：

（1）构造方法；

（2）setStart(int s)：用于指定等差数列的起始值；

（3）setD(int d)：用于指定等差数列的公差；

（4）getSum(int n)：用于计算等差数列ｎ项的和。并创建对象shulie对该类进行测试。
如果该文章对您有些许的帮助 请多点赞关注收藏
import java.util.Scanner;		//头文件 输入用的

class DengCha{
    int s,d,n,S;
    
    public DengCha(){
 System.out.println("对象已创建完成，可调用");
    }
    
void setStar(int s){
 this.s=s; //起始值
 System.out.println("起始值为"+s);
   }
   
void setD(int d){
 this.d=d; //公差
 System.out.println("公差为"+d);
   }

void getSum(int n){
 this.n=n;
 S=n*s+n*(n-1)*d/2;
 System.out.println("等差数列"+n+"项的和为："+S);
   }
}

public class Ex2_3{
   public static void main(String args[]){
   
 int a,b,c;
System.out.println("请输入起始值 公差 项数：");
 Scanner sc = new Scanner(System.in);
        a = sc.nextInt();
 	b = sc.nextInt();
 	c = sc.nextInt();
 	
DengCha shulie =new DengCha();
 shulie.setStar(a);
 shulie.setD(b);
 shulie.getSum(c);
}
}

代码以经过测试 结果如下

经常谈论起函数和方法，也常常搞不清楚它们之间的界限，经常把两个混用。首先来看看，两者是如何定义的？

　　函数（function）是可以执行的javascript代码块，由javascript程序定义或javascript实现预定义。函数可以带有实际参数或者形式参数，用于指定这个函数执行计算要使用的一个或多个值，而且还可以返回值，以表示计算的结果。

　　方法（method）是通过对象调用的javascript函数。也就是说，方法也是函数，只是比较特殊的函数。假设有一个函数是fn，一个对象是obj，那么就可以定义一个method：

 

 

有些概念我一直很困惑，譬如“面向对象”、“类”和“实例化”。

希望有人能用简洁的话语帮我解释下方法（method）和函数（function）的区别。在google上找到的那些答案对我来说太难理解了。 谢谢。

这个问题还是 willc2 在 2008 年 9 月 30 日在 StackOverflow 上提问的。

下面先来看看被选为最佳答案的回复（来自  Andrew Edgecombe ）：

函数是一段代码，通过名字来进行调用。它能将一些数据（参数）传递进去进行处理，然后返回一些数据（返回值），也可以没有返回值。

所有传递给函数的数据都是显式传递的。

方法也是一段代码，也通过名字来进行调用，但它跟一个对象相关联。方法和函数大致上是相同的，但有两个主要的不同之处：

方法中的数据是隐式传递的；
	
方法可以操作类内部的数据（请记住，对象是类的实例化–类定义了一个数据类型，而对象是该数据类型的一个实例化）
以上只是简略的解释，忽略了作用域之类的问题。

Raffi Khatchadourian 对 Andrew Edgecombe 答案的补充：

对于 1），你应当再加上“ 方法在 C++ 中是被称为成员函数”。因此，在 C++ 中的“方法”和“函数”的区别，就是“成员函数”和“函数”的区别。此外，诸如 Java 一类的编程语言只有“方法”。所以这时候就是“静态方法”和“方法”直接的区别。

对于2），你应当补上方法可以操作已在类中声明的私有实例（成员）数据。其他代码都可以访问公共实例数据。

Aaron 的回答：

方法和对象相关；

函数和对象无关。

Java中只有方法，C中只有函数，而C++里取决于是否在类中。