曲线拟合、多项式拟合、最小二乘法

news2024/11/23 3:40:41

最近在做自车轨迹预测的工作，遇到 曲线拟合、多项式拟合、最小二乘法这些概念有点不清晰，
做一些概念区别的总结：

曲线拟合用于查找一系列数据点的“最佳拟合”线或曲线。 大多数情况下，曲线拟合将产生一个函数，可用于在曲线的任何位置找到点。 在某些情况下，也可能不关心找到函数，而是只想使用曲线拟合来平滑数据并改善绘图的外观。

简而言之，曲线拟合就是在受到一定约束条件的情况下，构建可以表示一系列数据点的曲线或数学函数的过程。更加数学化一点的话，对于一个给定的数据集，曲线拟合是以方程形式引入因变量和自变量之间的数学关系的过程。

多项式拟合是假设函数模型是多项式，是曲线拟合中的夹着数据符合的函数模型， 还有其他曲线模型拟合，如线性回归，指数型函数，其他非线性曲线拟合；

曲线拟合结果可以有很多，也就是说解有很多，拟合结果的好坏如何评价，如果找到最优解， 最优解的评判标准是什么。那么“最佳”的准则是什么？可以是所有观测点到直线的距离和最小，也可以是所有观测点到直线的误差（真实值-理论值）绝对值和最小，也可以是其它。

请添加图片描述

早在19世纪，勒让德就认为让“误差的平方和最小”估计出来的模型是最接近真实情形的。这就是最小二乘法的思想，所谓“二乘”就是平方的意思。从这里我们可以看到，所以最小二乘法其实就是用来做函数拟合的一种思想或者准则。至于怎么求出具体的参数那就是另外一个问题了，理论上可以用导数法、几何法，工程上可以用梯度下降法。

因此最小二乘法（又称最小平方法）是一种数学优化思想。它通过最小化误差的平方和寻找数据的最佳函数匹配。利用最小二乘法可以简便地求得未知的数据，并使得这些求得的数据与实际数据之间误差的平方和为最小。最小二乘法可用于曲线拟合。其他一些优化问题也可通过最小化能量或最大化熵用最小二乘法来表达。

参考下方 C 代码改写实现接口 ：
实现的 2阶、 3阶 最小二乘 多项式拟合函数 C 语言接口：

2阶多项式
void QuadraticSpline(Point_xy *points, uint32 n, float32 *coeffs)
{
    coeffs[3] = 0;

    // 计算矩阵A和向量b
    float32 sum_x = 0.0, sum_x2 = 0.0, sum_y = 0.0, sum_xy = 0.0, sum_x3 = 0.0, sum_x4 = 0.0, sum_x2y = 0.0;
    for (uint32 i = 0; i < n; i++)
    {
        float32 xi = points[i].x, yi = points[i].y;
        sum_x += xi;
        sum_x2 += xi * xi;
        sum_y += yi;
        sum_xy += xi * yi;
        sum_x3 += xi * xi * xi;
        sum_x4 += xi * xi * xi * xi;
        sum_x2y += xi * xi * yi;
    }

    // 构造矩阵A和向量b
    float32 A[3][3] = {{n, sum_x, sum_x2},
                       {sum_x, sum_x2, sum_x3},
                       {sum_x2, sum_x3, sum_x4}};
    float32 b[3] = {sum_y, sum_xy, sum_x2y};

    // 求解线性方程组Ax=b
    for (uint8 k = 0; k < 3 - 1; k++)
    {
        for (uint8 i = k + 1; i < 3; i++)
        {
            float32 p = A[i][k] / A[k][k];
            for (uint8 j = k + 1; j < 3; j++)
            {
                A[i][j] -= p * A[k][j];
            }
            b[i] -= p * b[k];
        }
    }

    coeffs[2] = b[2] / A[2][2];
    coeffs[1] = (b[1] - A[1][2] * coeffs[2]) / A[1][1];
    coeffs[0] = (b[0] - A[0][1] * coeffs[1] - A[0][2] * coeffs[2]) / A[0][0];
}

3阶多项式
void CubicSpline(Point_xy* points, uint32 n, float32* coeffs)
{
    coeffs[3] = 0;

    // 计算矩阵A和向量b
    float32 sum_x = 0.0, sum_x2 = 0.0, sum_x3 = 0.0, sum_x4 = 0.0, sum_x5 = 0.0, sum_x6 = 0.0, sum_y = 0.0, sum_xy = 0.0, sum_x2y = 0.0, sum_x3y = 0.0;
    for (uint32 i = 0; i < n; i++)
    {
        float32 xi = points[i].x, yi = points[i].y;
        sum_x  += xi;
        sum_x2 += xi * xi;
        sum_x3 += xi * xi * xi;
        sum_x4 += xi * xi * xi * xi;
        sum_x5 += xi * xi * xi * xi * xi;
        sum_x6 += xi * xi * xi * xi * xi * xi;
        sum_y  += yi;
        sum_xy += xi * yi;
        sum_x2y += xi * xi * yi;
        sum_x3y += xi * xi * xi * yi;
    }

    // 构造矩阵A和向量b
    float32 A[4][4] = { {n, sum_x, sum_x2, sum_x3},
                       {sum_x, sum_x2, sum_x3, sum_x4},
                       {sum_x2, sum_x3, sum_x4,sum_x5},
                       {sum_x3, sum_x4, sum_x5,sum_x6}};

    float32 b[4] = { sum_y, sum_xy, sum_x2y,sum_x3y};

    // 求解线性方程组Ax=b
    for (uint8 k = 0; k < 4 - 1; k++)
    {
        for (uint8 i = k + 1; i < 4; i++)
        {
            float32 p = A[i][k] / A[k][k];
            for (uint8 j = k + 1; j < 4; j++)
            {
                A[i][j] -= p * A[k][j];
            }
            b[i] -= p * b[k];
        }
    }

    coeffs[3] = b[3] / A[3][3];
    coeffs[2] = (b[2] - A[2][3] * coeffs[3]) / A[2][2];
    coeffs[1] = (b[1] - A[1][2] * coeffs[2] - A[1][3] * coeffs[3]) / A[1][1];
    coeffs[0] = (b[0] - A[0][1] * coeffs[1] - A[0][2] * coeffs[2] - A[0][3] * coeffs[3]) / A[0][0];
}

C ++ 实现：
代码出处

#include <stdio.h>
#include "stdlib.h"
#include "math.h"
#include <vector>
using namespace std;
 
struct point
{
	double x;
	double y;
};
 
typedef vector<double> doubleVector;
vector<point> getFile(char *File);  //获取文件数据
doubleVector getCoeff(vector<point> sample, int n);   //矩阵方程
 
void main()
{
	int i, n;
	char *File = "XY.txt";
	vector<point> sample;
	doubleVector  coefficient;
	sample = getFile(File);
	printf("拟合多项式阶数n=");
	scanf_s("%d", &n);
	coefficient = getCoeff(sample, n);
	printf("\n拟合矩阵的系数为：\n");
	for (i = 0; i < coefficient.size(); i++)
		printf("a%d = %lf\n", i, coefficient[i]);
 
}
//矩阵方程
doubleVector getCoeff(vector<point> sample, int n)
{
	vector<doubleVector> matFunX;  //公式3左矩阵
	vector<doubleVector> matFunY;  //公式3右矩阵
	doubleVector temp;
	double sum;
	int i, j, k;
	//公式3左矩阵
	for (i = 0; i <= n; i++)
	{
		temp.clear();
		for (j = 0; j <= n; j++)
		{
			sum = 0;
			for (k = 0; k < sample.size(); k++)
				sum += pow(sample[k].x, j + i);
			temp.push_back(sum);
		}
		matFunX.push_back(temp);
	}
 
	//打印matFunX矩阵
	printf("matFunX矩阵：\n");
	for (i = 0;i < matFunX.size();i++) {
		for (j = 0;j < matFunX.size();j++)
			printf("%f\t", matFunX[i][j]);
		printf("\n");
	}
	printf("matFunX.size=%d\n", matFunX.size());
	//printf("matFunX[3][3]=%f\n", matFunX[3][3]);
 
	//公式3右矩阵
	for (i = 0; i <= n; i++)
	{
		temp.clear();
		sum = 0;
		for (k = 0; k < sample.size(); k++)
			sum += sample[k].y*pow(sample[k].x, i);
		temp.push_back(sum);
		matFunY.push_back(temp);
	}
	printf("matFunY.size=%d\n", matFunY.size());
	//打印matFunY的矩阵
	printf("matFunY的矩阵：\n");
	for (i = 0;i < matFunY.size();i++) {
			printf("%f\n", matFunY[i][0]);
	}
	//矩阵行列式变换，将matFunX矩阵变为下三角矩阵,将matFunY矩阵做怎样的变换呢？
	//AX=Y在将X变换为下三角矩阵X'时，是左右两边同乘ratio
	double num1, num2, ratio;
	for (i = 0; i < matFunX.size() - 1; i++)
	{
		num1 = matFunX[i][i];
		for (j = i + 1; j < matFunX.size(); j++)
		{
			num2 = matFunX[j][i];
			ratio = num2 / num1;
			for (k = 0; k < matFunX.size(); k++)
				matFunX[j][k] = matFunX[j][k] - matFunX[i][k] * ratio;
			matFunY[j][0] = matFunY[j][0] - matFunY[i][0] * ratio;
		}
	}
	//打印matFunX行列变化之后的矩阵
	printf("matFunX行列变换之后的矩阵：\n");
	for (i = 0;i < matFunX.size();i++) {
		for (j = 0;j < matFunX.size();j++)
			printf("%f\t", matFunX[i][j]);
		printf("\n");
	}
	//打印matFunY行列变换之后的矩阵
	printf("matFunY行列变换之后的矩阵：\n");
	for (i = 0;i < matFunY.size();i++) {
		printf("%f\n", matFunY[i][0]);
	}
	//计算拟合曲线的系数
	doubleVector coeff(matFunX.size(), 0);
	for (i = matFunX.size() - 1; i >= 0; i--)
	{
		if (i == matFunX.size() - 1)
			coeff[i] = matFunY[i][0] / matFunX[i][i];
		else
		{
			for (j = i + 1; j < matFunX.size(); j++)
				matFunY[i][0] = matFunY[i][0] - coeff[j] * matFunX[i][j];
			coeff[i] = matFunY[i][0] / matFunX[i][i];
		}
	}
	return coeff;
}
 
//获取文件数据
vector<point> getFile(char *File)
{
	int i = 1;
	vector<point> dst;
 
	FILE *fp = fopen(File, "r");
 
	if (fp == NULL)
	{
		printf("Open file error!!!\n");
		exit(0);
	}
 
	point temp;
	double num;
 
	while (fscanf(fp, "%lf", &num) != EOF)
	{
		if (i % 2 == 0)
		{
			temp.y = num;
			dst.push_back(temp);
		}
		else
			temp.x = num;
		i++;
	}
	fclose(fp);
	return dst;
}

改成C 语言：
代码出处

#include <stdio.h>
#include "stdlib.h"
#include "math.h"
//#include <vector>
//using namespace std;

#define MAX_EXP 4 /* x最高次幂 */
#define MATRIX_DIM (MAX_EXP + 1)   /* 矩阵阶数 */
#define SMPNUM 5    /* 采样个数 */

struct point
{
    double x;
    double y;
};

/* 采样点想， y */
float sampleX[SMPNUM] = {0.0};
float sampleY[SMPNUM] = {0.0};

void getFile(char *File);  //获取文件数据
void getCoeff(float sampleX[SMPNUM], float sampleY[SMPNUM], float coeff[MATRIX_DIM]);   //获取系数

int main()
{
    int i;
    char *File = "XY.txt";
    //vector<point> sample;
    //doubleVector  coefficient;
    //sample = getFile(File);
    getFile(File);
    printf("拟合多项式阶数n=");
    //scanf("%d", &n);
    // coefficient = getCoeff(sample, n);
    //n = 3;

    float coeff[MATRIX_DIM] = {0};
    getCoeff(sampleX, sampleY, coeff);
    printf("\n拟合矩阵的系数为：\n");
    for (i = 0; i < MATRIX_DIM; i++)
    {
        printf("a%d = %lf\n", i, coeff[i]);
    }

    return 0;
}
//矩阵方程
void getCoeff(float sampleX[SMPNUM], float sampleY[SMPNUM], float coeff[MATRIX_DIM])
{
    double sum;
    int i, j, k;

    float matX[MATRIX_DIM][MATRIX_DIM];  //公式3左矩阵
    float matY[MATRIX_DIM][MATRIX_DIM];  //公式3右矩阵
    float temp2[MATRIX_DIM];
    //公式3左矩阵
    for (i = 0; i < MATRIX_DIM; i++)
    {
        for (j = 0; j < MATRIX_DIM; j++)
        {
            sum = 0.0;
            for (k = 0; k < SMPNUM; k++)
            {
                sum += pow(sampleX[k], j + i);
            }
            matX[i][j] = sum;
        }
    }

    //打印matFunX矩阵
    printf("matFunX矩阵：\n");
    for (i = 0; i < MATRIX_DIM; i++)
    {
        for (j = 0; j < MATRIX_DIM; j++)
        {
            printf("%f\t", matX[i][j]);
        }
        printf("\n");
    }

    //公式3右矩阵
    for (i = 0; i < MATRIX_DIM; i++)
    {
        //temp.clear();
        sum = 0;
        for (k = 0; k < SMPNUM; k++)
        {
            sum += sampleY[k] * pow(sampleX[k], i);
        }
        matY[i][0] = sum;
    }
    //printf("matFunY.size=%d\n", matFunY.size());
    //打印matFunY的矩阵
    printf("matFunY的矩阵：\n");
    for (i = 0; i < MATRIX_DIM; i++)
    {
        printf("%f\n", matY[i][0]);
    }
    //矩阵行列式变换，将matFunX矩阵变为下三角矩阵,将matFunY矩阵做怎样的变换呢？
    //AX=Y在将X变换为下三角矩阵X'时，是左右两边同乘ratio
    double num1, num2, ratio;
    for (i = 0; i < MATRIX_DIM; i++)
    {
        num1 = matX[i][i];
        for (j = i + 1; j < MATRIX_DIM; j++)
        {
            num2 = matX[j][i];
            ratio = num2 / num1;
            for (k = 0; k < MATRIX_DIM; k++)
            {
                matX[j][k] = matX[j][k] - matX[i][k] * ratio;
            }
            matY[j][0] = matY[j][0] - matY[i][0] * ratio;
        }
    }
    //打印matFunX行列变化之后的矩阵
    printf("matFunX行列变换之后的矩阵：\n");
    for (i = 0; i < MATRIX_DIM; i++)
    {
        for (j = 0; j < MATRIX_DIM; j++)
        {
            printf("%f\t", matX[i][j]);
        }
        printf("\n");
    }
    //打印matFunY行列变换之后的矩阵
    printf("matFunY行列变换之后的矩阵：\n");
    for (i = 0; i < MATRIX_DIM; i++)
    {
        printf("%f\n", matY[i][0]);
    }
    //计算拟合曲线的系数
    //doubleVector coeff(n + 1, 0);
    for (i = MATRIX_DIM - 1; i >= 0; i--)
    {
        if (i == MATRIX_DIM - 1)
        {
            coeff[i] = matY[i][0] / matX[i][i];
        }
        else
        {
            for (j = i + 1; j < MATRIX_DIM; j++)
            {
                matY[i][0] = matY[i][0] - coeff[j] * matX[i][j];
            }
            coeff[i] = matY[i][0] / matX[i][i];
        }
    }
    return;
}

//获取文件数据
void getFile(char *File)
{
    int i = 0, j = 0, k = 0;
    //vector<point> dst;

    FILE *fp = fopen(File, "r");

    if (fp == NULL)
    {
        printf("Open file error!!!\n");
        exit(0);
    }

    point temp;
    double num;

    while (fscanf(fp, "%lf", &num) != EOF)
    {
        if (i % 2 == 0)
        {
            temp.x = num;
            sampleX[j++] = num;


        }
        else
        {
            temp.y = num;
            sampleY[k++] = num;
        }
        i++;
    }
    fclose(fp);
    return;
    //return dst;
}

C语言消元法求解代码实现：
代码出处

#define RANK_  	3  		多项式次数
/*
*********************************************************************************************************
*   函 数 名: polyfit
*   功能说明: 多项式曲线拟合（与matlab效果一致）
*   形    参: d_X	输入的数据的x值
			  d_Y	输入的数据的y值
			  d_N	输入的数据的个数
			  rank  多项式的次数
			  coeff 输出的系数
*   返 回 值: 无
*********************************************************************************************************
*/
//原理：At * A * C = At * Y	，其中 At 为 A 转置矩阵，C 为系数矩阵
void polyfit(double *d_X, double *d_Y, int d_N, int rank, double *coeff)
{
	if(RANK_ != rank)	//判断次数是否合法
		return;

	int i,j,k;	
	double aT_A[RANK_ + 1][RANK_ + 1] = {0};
	double aT_Y[RANK_ + 1] = {0};
	
	
	for(i = 0; i < rank + 1; i++)	//行
	{
		for(j = 0; j < rank + 1; j++)	//列
		{
			for(k = 0; k < d_N; k++)	
			{
				aT_A[i][j] +=  pow(d_X[k], i+j);		//At * A 线性矩阵
			}
		}
	}
	
	for(i = 0; i < rank + 1; i++)
	{
		for(k = 0; k < d_N; k++)
		{
			aT_Y[i] += pow(d_X[k], i) * d_Y[k];		//At * Y 线性矩阵
		}
	}
	
	//以下为高斯列主元素消去法解线性方程组
	for(k = 0; k < rank + 1 - 1; k++)
	{
		int row = k;
		double mainElement = fabs(aT_A[k][k]);
		double temp = 0.0;
		
		//找主元素
		for(i = k + 1; i < rank + 1 - 1; i++)
		{
			if( fabs(aT_A[i][i]) > mainElement )
			{
				mainElement = fabs(aT_A[i][i]);
				row = i;
			}
		}
		
		//交换两行
		if(row != k)
		{
			for(i = 0; i < rank + 1; i++)
			{
				temp = aT_A[k][i];
				aT_A[k][i] = aT_A[row][i];
				aT_A[row][i] = temp;
			}	
			temp = aT_Y[k];
			aT_Y[k] = aT_Y[row];
			aT_Y[row] = temp;
		}
			
		
		//消元过程
		for(i = k + 1; i < rank + 1; i++)
		{
			for(j = k + 1; j < rank + 1; j++)
			{
				aT_A[i][j] -= aT_A[k][j] * aT_A[i][k] / aT_A[k][k];
			}
			aT_Y[i] -= aT_Y[k] * aT_A[i][k] / aT_A[k][k];
		}
	}	
		
	//回代过程
	for(i = rank + 1 - 1; i >= 0; coeff[i] /= aT_A[i][i], i--)
	{
		for(j = i + 1, coeff[i] = aT_Y[i]; j < rank + 1; j++)
		{
			coeff[i] -= aT_A[i][j] * coeff[j];
		}
	}

	return;	
}

python 代码实现 多项式曲线拟合：
代码出处

'''
   多项式：yi = w0 + w1*xi^1 + w2*xi^2 + ... + wn*xi^m
   N为数据点个数，M为阶数
   先用数据点（xa、ya）求出未知参数，然后用参数带入后的公式求解给定值(xxa)
'''
import matplotlib.pyplot as plt
import numpy
import random
 
fig = plt.figure()
ax = fig.add_subplot(111)
 
# 在这里给出拟合多项式的阶数
order = 9
 
# 1. 生成曲线上的各个点
x = numpy.arange(-1,1,0.02)
y = [((a*a-1)*(a*a-1)*(a*a-1)+0.5)*numpy.sin(a*2) for a in x]   
 
# y=[(x^2-1)^3]*sin(2x)，阶数为6？？？
 
# ax.plot(x,y,color='r',linestyle='-',marker='')
# ,label="(a*a-1)*(a*a-1)*(a*a-1)+0.5"
plt.plot(x,y,c='red')
 
# 2. 生成的曲线上的各个点偏移一下，并放入到x_data,y_data中去
i=0
x_data=[]
y_data=[]
for xx in x:
    yy=y[i]
    d=float(random.randint(60,140))/100
    #ax.plot([xx*d],[yy*d],color='m',linestyle='',marker='.')
    i+=1
    x_data.append(xx*d)
    y_data.append(yy*d)
 
ax.plot(x_data,y_data,color='m',linestyle='',marker='.')
 
# 3. 计算Ax=b中，矩阵A、b
# 存储从0次到m次的所有冥方和
bigMat=[]
for j in range(0, 2*order+1):
    sum = 0
    for i in range(0,len(xa)):
        sum += (xa[i]**j)
    bigMat.append(sum)
 
# 计算线性方程组系数矩阵：A
matA=[]
for rowNum in range(0,order+1):
    row=bigMat[rowNum:rowNum+order+1]
    matA.append(row)
 
matA=numpy.array(matA)
 
matB=[]
for i in range(0,order+1):
    ty=0.0
    for k in range(0,len(xa)):
        ty+=ya[k]*(xa[k]**i)
    matB.append(ty)
 
matB=numpy.array(matB)
 
matW=numpy.linalg.solve(matA,matB)
# numpy.linalg中的函数solve可以求解形如 Ax = b 的线性方程组，其中 A 为矩阵，b 为一维或二维的数组，x 是未知变量
 
# 画出拟合后的曲线
# print(matW)
x_ = numpy.arange(-1,1.06,0.01)
y_ =[]
for i in range(0,len(xxa)):
    yy=0.0
    for j in range(0,order+1):
        dy = (x_[i]**j)*matW[j]
        # dy*=matW[j]
        yy += dy
    y_.append(yy)
ax.plot(x_,y_,color='g',linestyle='-',marker='')
 
ax.legend()
plt.show()

相关参考：
https://blog.csdn.net/qq_27586341/article/details/90170839
https://blog.csdn.net/MoreAction_/article/details/106443383
https://www.cnblogs.com/nhyq-wyj/p/14898517.html
https://sikasjc.github.io/2018/10/24/curvefitting/

https://blog.csdn.net/piaoxuezhong/article/details/54973750
https://blog.csdn.net/tutu1583/article/details/82111060

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1425103.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

1.26模拟退火

1.26模拟退火

模拟退火是爬山算法的一种&#xff0c;是搜索算法 初始阶段 即只有在每次更新方案时&#xff0c;才会使循环次数增加
阅读更多...
Maven安装，学习笔记，详细整理maven的一些配置

Maven安装，学习笔记，详细整理maven的一些配置

Maven 1. 初识Maven 2. Maven概述 Maven模型介绍 Maven仓库介绍 Maven安装与配置 3. IDEA集成Maven 4. 依赖管理 01. Maven课程介绍 1.1 课程安排 学习完前端Web开发技术后&#xff0c;我们即将开始学习后端Web开发技术。做为一名Java开发工程师&#xff0c;后端 Web开发技术…
阅读更多...
屈子祠镇黑鱼岭，不可移动文物预防性保护系统守遗珍

屈子祠镇黑鱼岭，不可移动文物预防性保护系统守遗珍

一、何止秦俑 秦陵苑囿青铜水禽等文物集中展出 文物保护&#xff0c;尤其是不可移动文物的保护&#xff0c;一直都是文化遗产的重要环节。湖南省汨罗市屈子祠镇双楚村黑鱼岭墓地&#xff0c;作为长江中游地区的重大考古发现&#xff0c;其商朝晚期的历史背景赋予其不可估量的历…
阅读更多...
鸿蒙开发实战-运动app开发

鸿蒙开发实战-运动app开发

主要开发内容 3.1 开发准备 想要实现以下功能的话&#xff0c;需要学习“Tabs”&#xff0c;“TabContent”&#xff0c;“Row”&#xff0c;“Column”&#xff0c;等等相关技术。 主页 静坐页面   除此之外&#xff0c;还需要先准备8张图标的图片以及应用开发所需要的图片…
阅读更多...
Python下载安装与环境配置

Python下载安装与环境配置

本文将指导您完成Python的下载、安装以及环境配置过程&#xff0c;确保您在编写和运行Python代码时能够获得最佳体验。我们将提供详细的步骤和代码示例&#xff0c;帮助您顺利完成设置。 一、Python下载与安装 访问Python官网&#xff1a;首先&#xff0c;您需要访问Python的官…
阅读更多...
Django模型(六）

Django模型(六）

一、其它查询 文档：https://docs.djangoproject.com/zh-hans/4.1/ref/models/querysets/#count 1.1、排序 Queryset.order_by(*fields) 默认情况下，QuerySet 返回的结果是按照模型 Meta 中的 ordering 选项给出的排序元组排序的 可以通过使用 order_by 方法在每个 QueryS…
阅读更多...
RocketMq5源码搭建

RocketMq5源码搭建

最近公司使用到了RocketMQ,所以打算研究一下RocketMQ 准备自己动手搭建一下RocketMq源码 前提 需要搭建jdk环境&#xff0c;jdk版本需要高于1.8 首先 从github 拉源码 源码地址&#xff1a;rocketMq源码传送门 启动namesrv 启动之前需要配置一下ROCKERMQ_HOME 配置如下&a…
阅读更多...
【C++】 C++入门—内联函数

【C++】 C++入门—内联函数

C入门 1 内联函数1.1 定义1.2 查看方式1.3 注意 Thanks♪(&#xff65;ω&#xff65;)&#xff89;谢谢阅读下一篇文章见&#xff01;&#xff01;&#xff01; 1 内联函数 1.1 定义 程序在执行一个函数前需要做准备工作&#xff1a;要将实参、局部变量、返回地址以及若干寄存…
阅读更多...
pnpm : 无法加载文件 D:\tool\nvm\nvm\node_global\pnpm.ps1，因为在此系统上禁止运行脚本

pnpm : 无法加载文件 D:\tool\nvm\nvm\node_global\pnpm.ps1，因为在此系统上禁止运行脚本

你们好&#xff0c;我是金金金。 场景 新创建的项目&#xff0c;在vscode编辑器终端输入 pnpm i&#xff0c;显示报错如上 解决 在终端输入get-ExecutionPolicy(查看执行策略/权限) 输出Restricted(受限的) 终端再次输入Set-ExecutionPolicy -Scope CurrentUser命令给用户赋予…
阅读更多...
如何在淘宝和Shopee上进行选品：策略和原则

如何在淘宝和Shopee上进行选品：策略和原则

在当今数字化时代&#xff0c;电商平台已经成为卖家们扩展业务和增加销售额的重要渠道。而在淘宝和Shopee这两个知名电商平台上进行选品时&#xff0c;卖家可以遵循一些相似的原则和策略&#xff0c;以确保他们的产品能够吸引目标客户并取得成功。本文将为您介绍一些在淘宝和Sh…
阅读更多...
uniapp H5 px转换rpx

uniapp H5 px转换rpx

uniapp H5 px转换rpx 安装 px2rpx 重启 HBuilderX在要转换的文件 点击右键 点击 开启px2rpx(1px转成2rpx) 开启成功&#xff01;使用 编辑页面后 按下键盘 Ctrl s 保存&#xff01;转化成功&#xff01;当然 你也需要对使用的插件 进行转换&#xff01;否则可能导致样式出现…
阅读更多...
基于Python的Selenium详细教程_

基于Python的Selenium详细教程_

一、PyCharm安装配置Selenium 本文使用环境&#xff1a;windows11、Python 3.10.5、PyCharm 2022.1.3、Selenium 4.3.0 需要你懂的技术&#xff1a;Python、HTML、CSS、JavaScript 1.Seleium安装&#xff1a; 在PyCharm终端或window命令窗口输入以下命令 #查看已安装的Pytho…
阅读更多...
指针深入了解7

指针深入了解7

1.qsort的模拟实现&#xff08;冒泡排序的原型制作&#xff09; 1.排序整型 int cmp_int(const void* p1, const void* p2) {return *((int*)p1) - *((int*)p2); } void swap(char* p1, char* p2)//完成交换 {int tmp *p1;*p1 *p2;*p2 tmp;} void bubble_sort(void* base,…
阅读更多...
Docker本地部署可编辑开源导航页并发布公网分享好友可访问

Docker本地部署可编辑开源导航页并发布公网分享好友可访问

文章目录 1. 使用Docker搜索镜像2. 下载镜像3. 查看镜像4. 启动容器5. 浏览器访问6. 远程访问6.1 内网穿透工具安装6.2 创建远程连接公网地址6.3 使用固定二级子域名地址远程访问 今天和大家分享如何使用Docker本地部署一个开源的简约风格网址导航页&#xff0c;支持五种搜索引…
阅读更多...
成熟的汽车制造供应商协同平台 要具备哪些功能特性？

成熟的汽车制造供应商协同平台 要具备哪些功能特性？

汽车行业是一个产业链长且“重”的行业&#xff0c;整个业务流程包括了研发、设计、采购、库存、生产、销售、售后等一系列环节&#xff0c;在每一个环节都涉及到很多信息交换的需求。对内要保证研发、采购、营销等业务环节信息流通高效安全&#xff0c;对外要与上、下游合作伙…
阅读更多...
【LeetCode每日一题】1109. 航班预订统计1094. 拼车 (差分数组)

【LeetCode每日一题】1109. 航班预订统计1094. 拼车 (差分数组)

差分数组 差分数组的主要适用场景是频繁对原始数组的某个区间的元素进行增减。 一、基本概念&#xff1a; 差分数组的定义如下&#xff1a; 假设原始数组为arr&#xff0c;差分数组为diff&#xff0c;其中diff[i] arr[i] - arr[i-1]&#xff08;0 < i < n&#xff0…
阅读更多...
机器学习 | 掌握逻辑回归在实践中的应用

机器学习 | 掌握逻辑回归在实践中的应用

目录 初识逻辑回归 逻辑回归实操 分类评估方法 初识逻辑回归 逻辑回归&#xff08;LogisticRegression&#xff09;是机器学习中的一种分类模型&#xff0c;逻辑回归是一种分类算法&#xff0c;虽然名字中带有回归&#xff0c;但是它与回归之间有一定的联系。由于算法的简单…
阅读更多...
搭建网站详细教程

搭建网站详细教程

一.领取一个免费域名和SSL证书&&CDN 特点&#xff1a;支持Cloudflare CDN Cloudflare是全球知名的CDN提供商&#xff0c;如果你不想暴露你的源站&#xff0c;又想使用我们的二级域名&#xff0c;不需要前往Cloudflare添加域名&#xff0c;修改NS记录&#xff0c;现在…
阅读更多...
Redux状态管理（运行机制及实例）

Redux状态管理（运行机制及实例）

背景&#xff1a; JavaScript需要管理的状态越来越多&#xff0c;越来越复杂;这些状态包括服务器返回的数据、缓存数据、用户操作产生的数据等等&#xff0c;也包括一些UI的状态&#xff0c;比如某些元素是否被选中&#xff0c;是否显示加载动效&#xff0c;当前分页。 状态之…
阅读更多...
prometheus的alertmanager监控报警

prometheus的alertmanager监控报警

监控告警&#xff1a; alert是一个单独的模块&#xff0c;需要我们单独的配置。 需要声明一个邮箱地址。配置是以configmap进行部署。 alert 实验&#xff1a; vim alert-cfg.yaml apiVersion: v1 kind: ConfigMap metadata:name: alertmanagernamespace: monitor-sa data…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023