二维三次样条插值

最新推荐文章于 2023-07-08 20:14:54 发布
最新推荐文章于 2023-07-08 20:14:54 发布
阅读量1w 收藏 11
点赞数 1
分类专栏： 3D与数值分析 文章标签： float delete math null im system
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaodan007/article/details/5691141
版权

#pragma once


namespace Math_BiCubic
{
 template<typename T>
 bool GetTable(T***& out_fTable, int in_iTH, int in_iTW, int in_iTK)
 {
  out_fTable = 0;
  out_fTable = new T**[in_iTH];
  if( 0 == out_fTable)
   return false;
  for(int i=0; i<in_iTH; i++)
  {
   out_fTable[i] = new T*[in_iTW];
   if( 0 == out_fTable[i])
    return false;
   for(int j=0; j<in_iTW; j++)
   {
    out_fTable[i][j] = new T[in_iTK];
    if( 0 == out_fTable[i][j])
     return false;
   }
  }
  for(int i=0; i<in_iTH; i++)
  {
   for(int j=0; j<in_iTW; j++)
   {
    for(int k=0; k<in_iTK; k++)
     out_fTable[i][j][k] = 0;
   }
  }
 }

 template<typename T>
 void DeleteTable(T*** in_dTable, int in_iTH, int in_iTW)
 {
  for(int i=0; i<in_iTH; i++)
  {
   for(int j=0; j<in_iTW; j++)
   {
    delete[] in_dTable[i][j];
    in_dTable[i][j] = 0;
   }
   delete[] in_dTable[i];
   in_dTable[i] = 0;
  }
  delete[] in_dTable;
  in_dTable = 0;
 }

 template<typename T>
 void Sort(T* in_tData, int in_iSize)
 {
  for(int i=0; i<in_iSize; i++)
  {
   int iRecored = i;
   for(int j=i+1; j<in_iSize; j++)
   {
    if( in_tData[j] < in_tData[iRecored])
     iRecored = j;
   }
   if( i != iRecored)
   {
    T tTemp = in_tData[i];
    in_tData[i] = in_tData[iRecored];
    in_tData[iRecored] = tTemp;
   }
  }
 }

 

 /* 三次样条曲线
 out_fVal   所求函数值
 out_fD1  所求插值点的一阶导数
 out_fD2 所求插值点的二阶导数
 in_iM 已知节点个数
 in_fPos    所求插值点的插值点的X轴坐标(无次序要求且可含已知点)
 in_fKnowPos,in_fKnowVal  已知点的节点坐标(要求升序排列)
 in_fKnowD1,  in_fKnowD2 已知点的节点的一阶导和二阶导(要求升序排列)
 in_iN 已知节点个数
 */
 void CubicSpline(float out_fVal[], float out_fD1[], float out_fD2[],
      float in_fPos[], int in_iM,
      float in_fKnowPos[], float in_fKnowVal[],
      float in_fKnowD1[], float in_fKnowD2[],
      int in_iN);


 //以估计的方法计算导数
 void CalculateDyDdy(float out_fD1[], float out_fD2[], 
      float in_fPos[], float in_fVal[], int in_iN,
      float in_fStartD1 = 0, float in_fEndD1 = 0,
      float in_fStartD2 = 0, float in_fEndD2 = 0);

 /* 三次样条曲线
 out_fVal   所求函数值
 in_fPos    所求插值点的插值点的X轴坐标(无次序要求且可含已知点)
 in_iM 已知节点个数
 in_fKnowPos  已知点的节点坐标(要求升序排列)
 in_fKnowVal  已知点的节点坐标值(要求升序排列)
 in_iN 已知节点个数
 */
 //三次样条曲线(1维(输出结果可含已知点))
 void CubicSplineEx(float* out_fVal, float* in_fPos, int in_iM,
  float* in_fKnowPos, float* in_fKnowVal, int in_iN);


 //三次样条曲线(2维)
 bool CubicSplineEx2_ROW(float*** inout_fVal,int in_iValRows,int in_iValLines,
  float*** in_fKnowVal,int in_iKnowRows,int in_iKnowLines);

 //三次样条曲线(2维)
 bool CubicSplineEx2_LINE(float*** inout_fVal,int in_iValRows,int in_iValLines,
  float*** in_fKnowVal,int in_iKnowRows,int in_iKnowLines);

 //三次样条曲线(2维)
 bool CubicSplineEx2_RowLine(float*** inout_fVal,int in_iValRows,int in_iValLines,
  float*** in_fKnowVal,int in_iKnowRows,int in_iKnowLines);

 //三次样条曲线(2维)
 bool CubicSplineEx2_LineRow(float*** inout_fVal,int in_iValRows,int in_iValLines,
  float*** in_fKnowVal,int in_iKnowRows,int in_iKnowLines);
}

///

 

#include "Math_BiCubic.h"


#define NULL 0

//以估计的方法计算导数
void Math_BiCubic::CalculateDyDdy(float out_fD1[], float out_fD2[], 
     float in_fPos[], float in_fVal[], int in_iN,
     float in_fStartD1, float in_fEndD1,
     float in_fStartD2, float in_fEndD2)
{//以估计的方法计算导数
 out_fD1[0] = in_fStartD1;
 out_fD2[0] = in_fStartD2;
 out_fD1[in_iN-1] = in_fEndD1;
 out_fD2[in_iN-1] = in_fEndD2;
 for(int i=1; i<in_iN-1; i++)
 {
  float dx = in_fPos[i+1] - in_fPos[i];
  if( 0 != dx)
  {
   out_fD1[i] = (in_fVal[i+1] - in_fVal[i]) / (2*dx);
   out_fD2[i] = (in_fVal[i+1] + in_fVal[i-1] - 2*in_fVal[i]) / dx / dx;
  }
 }
}


/* 三次样条曲线
out_fVal   所求函数值
out_fD1  所求插值点的一阶导数
out_fD2 所求插值点的二阶导数
in_iM 已知节点个数
in_fPos    所求插值点的插值点的X轴坐标(无次序要求且可含已知点)
in_fKnowPos,in_fKnowVal  已知点的节点坐标(要求升序排列)
in_fKnowD1,  in_fKnowD2 已知点的节点的一阶导和二阶导(要求升序排列)
in_iN 已知节点个数
*/
void Math_BiCubic::CubicSpline(float out_fVal[], float out_fD1[], float out_fD2[],
     float in_fPos[], int in_iM,
     float in_fKnowPos[], float in_fKnowVal[],
     float in_fKnowD1[], float in_fKnowD2[],
     int in_iN)  
{
 //三次样条函数
 int   i,j;  
 float   h0,h1,alpha,beta,g;
 int SCOUN = (in_iM<400)? 400:(in_iM/3);
 float* s = new float[in_iM];

 in_fKnowD1[0]=-0.5;  
 h0=in_fKnowPos[1]-in_fKnowPos[0];  
 s[0]=3.0*(in_fKnowVal[1]-in_fKnowVal[0])/(2.0*h0)-in_fKnowD2[0]*h0/4.0;  
 for(j=1;j<=in_iN-2;j++)  
 {
   h1=in_fKnowPos[j+1]-in_fKnowPos[j];  
   alpha=h0/(h0+h1);  
   beta=(1.0-alpha)*(in_fKnowVal[j]-in_fKnowVal[j-1])/h0;  
   beta=3.0*(beta+alpha*(in_fKnowVal[j+1]-in_fKnowVal[j])/h1);
   in_fKnowD1[j]=-alpha/(2.0+(1.0-alpha)*in_fKnowD1[j-1]);  
   s[j]=(beta-(1.0-alpha)*s[j-1]);  
   s[j]=s[j]/(2.0+(1.0-alpha)*in_fKnowD1[j-1]);  
   h0=h1;  
 }

 in_fKnowD1[in_iN-1]=(3.0*(in_fKnowVal[in_iN-1]-in_fKnowVal[in_iN-2])/h1+in_fKnowD2[in_iN-1]*h1/2.0-s[in_iN-2])/(2.0+in_fKnowD1[in_iN-2]);  
 for(j=in_iN-2;j>=0;j--)
   in_fKnowD1[j]=in_fKnowD1[j]*in_fKnowD1[j+1]+s[j];  
 for(j=0;j<=in_iN-2;j++)  
   s[j]=in_fKnowPos[j+1]-in_fKnowPos[j];  
 for(j=0;j<=in_iN-2;j++)
 {
   h1=s[j]*s[j];
   in_fKnowD2[j]=6.0*(in_fKnowVal[j+1]-in_fKnowVal[j])/h1-2.0*(2.0*in_fKnowD1[j]+in_fKnowD1[j+1])/s[j];
 }  
 h1=s[in_iN-2]*s[in_iN-2];  
 in_fKnowD2[in_iN-1]=6.*(in_fKnowVal[in_iN-2]-in_fKnowVal[in_iN-1])/h1+2.*(2.*in_fKnowD1[in_iN-1]+in_fKnowD1[in_iN-2])/s[in_iN-2];  
 g=0.0;  
 for(i=0;i<=in_iN-2;i++)
 {
   h1=0.5*s[i]*(in_fKnowVal[i]+in_fKnowVal[i+1]);
   h1=h1-s[i]*s[i]*s[i]*(in_fKnowD2[i]+in_fKnowD2[i+1])/24.0;
   g=g+h1;
 }  

 for(j=0;j<=in_iM-1;j++)
 {
   if(in_fPos[j]>=in_fKnowPos[in_iN-1])  
    i=in_iN-2;
   else
   {
    i=0;
    while(in_fPos[j]>in_fKnowPos[i+1])  
     i=i+1;
   }  
   h1=(in_fKnowPos[i+1]-in_fPos[j])/s[i];  
   h0=h1*h1;  
   out_fVal[j]=(3.0*h0-2.0*h0*h1)*in_fKnowVal[i];  
   out_fVal[j]=out_fVal[j]+s[i]*(h0-h0*h1)*in_fKnowD1[i];  
   out_fD1[j]=6.0*(h0-h1)*in_fKnowVal[i]/s[i];  
   out_fD1[j]=out_fD1[j]+(3.0*h0-2.0*h1)*in_fKnowD1[i];  
   out_fD2[j]=(6.0-12.0*h1)*in_fKnowVal[i]/(s[i]*s[i]);  
   out_fD2[j]=out_fD2[j]+(2.0-6.0*h1)*in_fKnowD1[i]/s[i];  
   h1=(in_fPos[j]-in_fKnowPos[i])/s[i];  
   h0=h1*h1;  
   out_fVal[j]=out_fVal[j]+(3.0*h0-2.0*h0*h1)*in_fKnowVal[i+1];  
   out_fVal[j]=out_fVal[j]-s[i]*(h0-h0*h1)*in_fKnowD1[i+1];  
   out_fD1[j]=out_fD1[j]-6.0*(h0-h1)*in_fKnowVal[i+1]/s[i];  
   out_fD1[j]=out_fD1[j]+(3.0*h0-2.0*h1)*in_fKnowD1[i+1];  
   out_fD2[j]=out_fD2[j]+(6.0-12.0*h1)*in_fKnowVal[i+1]/(s[i]*s[i]);  
   out_fD2[j]=out_fD2[j]-(2.0-6.0*h1)*in_fKnowD1[i+1]/s[i];
 }

 if( NULL != s)
  delete s;
 s = NULL;
}

//三次样条曲线(1维(输出结果可含已知点))
void Math_BiCubic::CubicSplineEx(float* out_fVal, float* in_fPos, int in_iM, float* in_fKnowPos, float* in_fKnowVal, int in_iN)
{
 float* fKnowDy = new float[in_iN];
 float* fKnowDdy = new float[in_iN];
 float* fInsertDy = new float[in_iM];
 float* fInsertDdy = new float[in_iM];

 Math_BiCubic::CalculateDyDdy(fKnowDy, fKnowDdy, in_fKnowPos, in_fKnowVal, in_iN);
 Math_BiCubic::CubicSpline(out_fVal, fInsertDy, fInsertDdy, in_fPos, in_iM,
  in_fKnowPos, in_fKnowVal, fKnowDy, fKnowDdy, in_iN);

 for(int i=0; i<in_iM; i++)
 {
  int iRecored = i;
  for(int j=i+1; j<in_iM; j++)
  {
   if( in_fPos[j] < in_fPos[iRecored])
    iRecored = j;
  }
  if( i != iRecored)
  {
   float fTemp = in_fPos[i];
   in_fPos[i] = in_fPos[iRecored];
   in_fPos[iRecored] = fTemp;
   
   fTemp = out_fVal[i];
   out_fVal[i] = out_fVal[iRecored];
   out_fVal[iRecored] = fTemp;
  }
 }

 if( NULL != fInsertDdy)
  delete fInsertDdy;
 fInsertDdy = NULL;
 if( NULL != fInsertDy)
  delete fInsertDy;
 fInsertDy = NULL;
 if( NULL != fKnowDdy)
  delete fKnowDdy;
 fKnowDdy = NULL;
 if( NULL != fKnowDy)
  delete fKnowDy;
 fKnowDy = NULL;
}

//三次样条曲线(2维)
bool Math_BiCubic::CubicSplineEx2_ROW(float*** inout_fVal,int in_iValRows,int in_iValLines,
          float*** in_fKnowVal,int in_iKnowRows,int in_iKnowLines)
{
 if( in_iValRows < in_iKnowRows || in_iKnowRows <= 0)
  return false;

 // Rows
 const int ROWK = (in_iValRows-1)/(in_iKnowRows-1);
 float* fPos = new float[in_iValLines];
 float* fVal = new float[in_iValLines];
 float* fKnowPos = new float[in_iKnowLines];
 float* fKnowVal = new float[in_iKnowLines];
 for(int i=0; i<in_iValRows; i+=ROWK)
 {
  for(int j=0; j<in_iValLines; j++)
  {
   fPos[j] = inout_fVal[i][j][0];
  }
  for(int j=0; j<in_iKnowLines; j++)
  {
   fKnowPos[j] = in_fKnowVal[i/ROWK][j][0];
   fKnowVal[j] = in_fKnowVal[i/ROWK][j][2];
  }

  CubicSplineEx(fVal,fPos,in_iValLines,fKnowPos,fKnowVal,in_iKnowLines);

  for(int j=0; j<in_iValLines; j++)
  {
   inout_fVal[i][j][2] = fVal[j];
  }
 }
 if( NULL != fPos)
  delete fPos;
 fPos = NULL;
 if( NULL != fVal)
  delete fVal;
 fVal = NULL;
 if( NULL != fKnowPos)
  delete fKnowPos;
 fKnowPos = NULL;
 if( NULL != fKnowVal)
  delete fKnowVal;
 return true;
}

//三次样条曲线(2维)
bool Math_BiCubic::CubicSplineEx2_LINE(float*** inout_fVal,int in_iValRows,int in_iValLines,
          float*** in_fKnowVal,int in_iKnowRows,int in_iKnowLines)
{
 if( in_iValLines < in_iKnowLines || in_iKnowLines<=1 )
  return false;

 // Line
 const int LINIK = (in_iValLines-1)/(in_iKnowLines-1);
 float* fPos = new float[in_iValRows];
 float* fVal = new float[in_iValRows];
 float* fKnowPos = new float[in_iKnowRows];
 float* fKnowVal = new float[in_iKnowRows];
 for(int i=0; i<in_iValLines; i+=LINIK)
 {
  for(int j=0; j<in_iValRows; j++)
  {
   fPos[j] = inout_fVal[j][i][1];
  }
  for(int j=0; j<in_iKnowRows; j++)
  {
   fKnowPos[j] = in_fKnowVal[j][i/LINIK][1];
   fKnowVal[j] = in_fKnowVal[j][i/LINIK][2];
  }

  CubicSplineEx(fVal,fPos,in_iValRows,fKnowPos,fKnowVal,in_iKnowRows);

  for(int j=0; j<in_iValRows; j++)
  {
   inout_fVal[j][i][2] = fVal[j];
  }
 }
 if( NULL != fPos)
  delete fPos;
 fPos = NULL;
 if( NULL != fVal)
  delete fVal;
 fVal = NULL;
 if( NULL != fKnowPos)
  delete fKnowPos;
 fKnowPos = NULL;
 if( NULL != fKnowVal)
  delete fKnowVal;

 return true;
}


//三次样条曲线(2维)
bool Math_BiCubic::CubicSplineEx2_RowLine(float*** inout_fVal,int in_iValRows,int in_iValLines,
            float*** in_fKnowVal,int in_iKnowRows,int in_iKnowLines)
{
 CubicSplineEx2_ROW(inout_fVal,in_iValRows,in_iValLines,in_fKnowVal,in_iKnowRows,in_iKnowLines);
 const int ROWK = (in_iValRows-1)/(in_iKnowRows-1);
 float*** fKnow = NULL;
 GetTable(fKnow,in_iKnowRows,in_iValLines,3);
 for(int i=0; i<in_iKnowRows; i++)
 {
  for(int j=0; j<in_iValLines; j++)
  {
   fKnow[i][j][0] = inout_fVal[i*ROWK][j][0];
   fKnow[i][j][1] = inout_fVal[i*ROWK][j][1];
   fKnow[i][j][2] = inout_fVal[i*ROWK][j][2];
  }
 }
 CubicSplineEx2_LINE(inout_fVal,in_iValRows,in_iValLines,fKnow,in_iKnowRows,in_iValLines);
 DeleteTable(fKnow,in_iKnowRows,in_iValLines);
 return true;
}


//三次样条曲线(2维)
bool Math_BiCubic::CubicSplineEx2_LineRow(float*** inout_fVal,int in_iValRows,int in_iValLines,
            float*** in_fKnowVal,int in_iKnowRows,int in_iKnowLines)
{
 CubicSplineEx2_LINE(inout_fVal,in_iValRows,in_iValLines,in_fKnowVal,in_iKnowRows,in_iKnowLines);
 const int LINIK = (in_iValLines-1)/(in_iKnowLines-1);
 float*** fKnow = NULL;
 GetTable(fKnow,in_iValRows,in_iKnowLines,3);
 for(int i=0; i<in_iValRows; i++)
 {
  for(int j=0; j<in_iKnowLines; j++)
  {
   fKnow[i][j][0] = inout_fVal[i][j*LINIK][0];
   fKnow[i][j][1] = inout_fVal[i][j*LINIK][1];
   fKnow[i][j][2] = inout_fVal[i][j*LINIK][2];
  }
 }
 CubicSplineEx2_ROW(inout_fVal,in_iValRows,in_iValLines,fKnow,in_iValRows,in_iKnowLines);
 DeleteTable(fKnow,in_iValRows,in_iKnowLines);
 return true;
}

 

 

#include <iostream>
#include "Math_BiCubic.h"

using namespace std;


void main()
{
 //const int AN = 10;
 //const int KN = 5;
 float AnsValue[AN+KN];
 float AnsPos[AN+KN];
 float KnowValue[KN];
 float KnowPos[KN];
 for(int i=AN; i>=0; i--)
 {
  AnsPos[AN-i] = i-1;
 }
 for(int i=0; i<KN; i++)
 {
  KnowPos[i] = 0.5+i;
  KnowValue[i] = i+i*i+1;
 }
 for(int i=0; i<KN; i++)
 {
  AnsPos[i+AN] = KnowPos[KN-i-1];
 }
 for(int i=0; i<AN+KN; i++)
  cout<<AnsPos[i]<<endl;
 cout<<endl;

 Math_BiCubic::CubicSplineEx(AnsValue,AnsPos,AN+KN,KnowPos,KnowValue,KN);

 for(int i=0; i<KN; i++)
 {
  cout<<KnowPos[i]<<": "<<KnowValue[i]<<endl;
 }
 cout<<endl;

 for(int i=0; i<AN+KN; i++)
  cout<<AnsPos[i]<<": "<<AnsValue[i]<<endl;


 const int AN = 9;
 const int KN = 5;
 float*** fKnow = NULL;
 float*** fRet = NULL;
 Math_BiCubic::GetTable(fKnow,KN,KN,3);
 Math_BiCubic::GetTable(fRet,AN,AN,3);

 for(int i=0; i<KN; i++)
 {
  for(int j=0; j<KN; j++)
  {
   fKnow[i][j][0] = 0.5+j;
   fKnow[j][i][1] = 0.5+j;
  }
 }

 for(int i=0; i<KN; i++)
 {
  for(int j=i; j<KN; j++)
  {
   fKnow[i][j][2] = j+j*j+1;
   fKnow[j][i][2] = j+j*j+1;
  }
 }

 for(int i=0; i<AN; i++)
 {
  for(int j=0; j<AN; j++)
  {
   fRet[i][j][0] = 0.5+j*0.5;
   fRet[i][j][1] = 0.5+i*0.5;
  }
 }

 


 for(int i=0; i<KN; i++)
 {
  for(int j=0; j<KN; j++)
  {
   cout<<"("<<fKnow[i][j][1]<<","<<fKnow[i][j][0]<<")";
  }
  cout<<endl;
 }

 for(int i=0; i<KN; i++)
 {
  for(int j=0; j<KN; j++)
  {
   cout<<fKnow[i][j][2]<<" ";
  }
  cout<<endl;
 }
 cout<<endl;

 for(int i=0; i<AN; i++)
 {
  for(int j=0; j<AN; j++)
  {
   cout<<"("<<fRet[i][j][1]<<","<<fRet[i][j][0]<<") ";
  }
  cout<<endl;
 }
 cout<<endl;

 Math_BiCubic::CubicSplineEx2_RowLine(fRet,AN,AN,fKnow,KN,KN);

 cout.width(8);
 cout.flags(ios::right);
 for(int i=0; i<AN; i++)
 {
  for(int j=0; j<AN; j++)
  {
   cout<<fRet[i][j][2]<<"   ";
  }
  cout<<endl;
 }

 //for(int i=0; i<AN; i++)
 //{
 // for(int j=0; j<AN; j++)
 // {
 //  cout<<fRet[j][i][1]<<" ";
 // }
 // cout<<endl;
 //}


 Math_BiCubic::DeleteTable(fRet,AN,AN);
 Math_BiCubic::DeleteTable(fKnow,KN,KN);

 system("pause");
}

/*
0.160714
1.83929
4.73214
9.73214
16.8393
25.1607
32.1964
35.375
32.125
19.8751
Press any key to continue . . .
*/

xiaodan007
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
PCL 三次样条插值（二维点）
dayuhaitang1的博客
06-22 331
PCL 三次样条插值（二维点）
九种常见的二维插值方法
love code, love life.
03-08 2万+
1、Bilinear interpolation双线性插值 双线性插值在数学上，双线性插值是线性插值的一种推广，用于在二维直线网格上插值两个变量（如x和y）的函数。 双线性插值首先在一个方向上使用线性插值，然后在另一个方向上使用线性插值。虽然每一步在采样值和位置上都是线性的，但是插值作为一个整体在采样位置上不是线性的而是二次的。 双线性插值是计算机视觉和图像处理中最基本的重采样技术之一，也称为双线性滤波或双线性纹理映射 2、Bicubic interpolation双三次插值 在数学中，双三次插值
二维三次卷积插值算法
Bettarwang的专栏
09-08 8391
在生产或生活中，我们往往只能得到有限的关于某个物理量的离散点（比如一张图片，我们只能得到其原大小内每个坐标处的颜色信息），但是很多时候，我们还需要不在已有栅格点的物理量信息（比如图像缩放时）。此时，就需要某种估计方法，用于得到该坐标处的物理量值，此时就需要通过插值得到。常用的插值算法有很多，从简单的线性插值，Lagrange插值，Newton插值，到较复杂的Herminate插值，二维三次卷积插值
插值方法(一维插值、三次样条插值、二维插值的matlab自带函数，python实现/作图)
weixin_45775970的博客
04-25 8777
数模比赛中，常常需要根据已知的函数点进行数据、模型的处理和分析，而有时候现有的数据是极少的，不足以支撑分析的进行，这时就需要使用一些数学的方法，“模拟产生”一些新的单又比较靠谱的值来满足需求，这就是插值的作用。 插值法在数值分析课程中有详细介绍。 一维插值函数 y = interp1(x0, y0, x, ‘menthod’) **method **指定插值的方法，默认为线性插值。其值可为： ‘nearest’ 最近项插值 ‘linear’ 线性插值 ‘spline’ 立方样条插.
基于MATLAB的二维与三维插值拟合运算（附完整代码）
forest_LL的博客
04-24 1万+
· 一. 一维插值 interp1函数在上个博客中（如下链接）已经更新了，此处再补充两个相关例题。 基于MATLAB的数据插值运算：Lagrange与Hermite算法（附完整代码）_唠嗑！的博客-CSDN博客 例题1 自行选择来自函数f(x)的数据点： 根据选择的数据进行插值处理，得出曲线。 解： MATLAB代码如下： clc;clear; x=0:0.12:1; y=(x.^2-3*x+5).*exp(-5*x).*sin(x); %调用interp1()函数 x1=0:.
数学建模十大算法02—插值与拟合（拉格朗日插值、三次样条插值、线性最小二乘法……）
Serendipity_zyx的博客
09-01 4334
数据建模涉及到的插值与拟合方法。
数学建模——插值（下）
m0_63024355的博客
07-04 2498
本文是面向数学建模准备的，是介绍性文章，没有过多关于原理的说明！！！
三次样条插值
reFreever的专栏
01-24 5861
一、样条函数的定义 样条函数属于分段光滑插值，他的基本思想是，在由两相邻节点所构成的每一个小区间内用低次多项式来逼近，并且在各结点的连接处又保证是光滑的(即导数连续)。 设在区间[a,b]上给定一组结点X: ,和一组对应的函数值。若函数S(x)满足下列条件： (1)在每一个子区间(k=1,2,...n)上，S(x)是一个不超过三次的多项式。 (2)在每一个结点上满足S(xi)=yi,
ImageInterpolation:从一维到二维生成三次样条和二次三次插值算法
06-10
从一维到二维生成三次样条和二次三次插值算法 在高分辨率显示器上显示低分辨率图像时，例如在高清电视机上观看标清电视节目时，观众或播放器必须插入丢失的像素，如下图所示。 图中，黄点为分辨率图像的像素点，白点...
三次样条插值函数c++实现
12-05
三次样条插值是一种在离散数据点之间构造平滑连续曲线的方法，广泛应用于数据拟合、数值分析、计算机图形学等领域。C++是实现这一算法的常用编程语言，其强大的面向对象特性使得构建这样的数学工具类变得方便。在这...
MATLAB三次样条插值算法
06-18
MATLAB作为一款强大的科学计算软件，提供了多种插值工具，其中包括三次样条插值算法。本文将深入探讨MATLAB中的三次样条插值，以及如何在实际应用中利用这种算法。 三次样条插值是一种连续且一阶、二阶可微的插值...
三次样条插值的matlab代码
11-06
三次样条插值，利用matlab语言实现。边界导数按照向内差分获得，无需手动输入。相比matlab自带spline函数，运算速度更快。
Matlab各种插值法.part6.zip_newton_三次样条插值_二维插值_插值_插值matlab
07-14
本文将详细介绍标题和描述中提到的几种插值方法：Newton插值、三次样条插值以及二维插值，以及它们在Matlab中的实现。 1. **Newton插值**： Newton插值，也称为Newton向前差分公式，是基于导数的一种插值方法。它...
拟合函数：线性插值_样条插值(一维，二维，三维)_最小二乘拟合
一只懒猫的博客
08-04 4662
拉格朗日插值法： 可以用于少样本点的情况，一定可以返回较好的插值函数。当样本点较多时，函数复杂度急剧上升。 样条插值法： 低阶多项式进行拟合，误差比拉格朗日稍大，但是避免了龙格现象。 ...
双线性插值和双三次插值
热门推荐
天才樱木
06-05 2万+
线性插值先讲一下线性插值：已知数据 (x0, y0) 与 (x1, y1)，要计算 [x0, x1] 区间内某一位置 x 在直线上的y值（反过来也是一样，略）：y−y0x−x0=y1−y0x1−x0y=x1−xx1−x0y0+x−x0x1−x0y1上面比较好理解吧，仔细看就是用x和x0，x1的距离作为一个权重，用于y0和y1的加权。双线性插值本质上就是在两个方向上做线性插值。双线性插值在数学上，双...
Python之建模数值逼近篇--二维插值
风信子的猫Redamancy的快乐星球
01-24 1万+
Python之建模数值逼近篇--二维插值介绍插值节点为网络节点插值节点为散乱节点 介绍 前面讲述的都是一维插值，即节点为一维变量，插值函数是一元函数（曲线）。若节点是二维的，插值函数就是二元函数，即曲面。如在某区域测量了若干点（节点）的高程（节点值），为了画出较精确的等高线图，就要先插入更多的点（插值点），计算这些点的高程（插值）。 插值节点为网络节点 已知m x n个节点:(xi,yj,zij)(i=1,2,…,m;j=1,2,…,n),且x1<…<xm;y.<…<yn。求点(x
基于matlab的二维散乱点3次闭合B样条拟合
ShutaoTANG的博客
07-08 542
基于matlat平台，开发了基于二维无序散乱点的三次B样条逼近算法。样条为闭合曲线，主要用于轮廓建模。
python 流场 二维样条插值方法
最新发布
10-01
这里的`method='cubic'`表示使用三次样条插值方法。 最后，可以根据插值结果显示流场。可以使用`matplotlib.pyplot`库来绘制： ```python import matplotlib.pyplot as plt plt.figure() plt.quiver(xi, yi, zi[:, ...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值