Código fuente derivado
La imagen adjunta es el resultado de la ejecución.
#¿Incluir? " stdio.h "
#¿Contiene? " math.h "
#¿Contiene? "Interpolación. h "
¿No es válido? interpolation_akima(AKINTEP?ap){?
intnum, k, kk, m, l
¿Doble? pio, *mtr, *x, *y, u[5], p, q;
num = AP->n;? k = AP->k;
Pio = AP->t;? mtr=ap->.
s;?
x = AP->x;? y = AP->y;
¿Si? (num & lt1)?{
Regresar;
}
¿Y si? ¿si? (núm==1)? {?
mtr[0]= mtr[4]= y[0];?
Regresar;
}
¿Y si? ¿si? (núm==2)? {?
mtr[0]= y[0];?
mtr[1]=(y[1]-y[0])/(x[1]-x[0]);
¿Y si? (k & lt0)?
mtr[4]=(y[0]*(Pio-x[1])-y[1]*(Pio-x[0])/(x[ 0]-x[1]);
Devolver;
}
¿Si? (k & lt0)?{?
¿Qué pasa si? (pio & lt=x[1])? kk = 0;
¿Qué pasa si? (pio & gt=x[num-1])? ?
kk = 1;? m = num
¿Cuándo? (((kk-m)!= 1); & amp( (kk-m)! =-1) )?{?
l =(kk+m)/2;
Si? (pio & ltx[l-1]) ?m = l;
¿Qué pasa si kk = l;
}?
kk-;
}
}
¿Qué pasa si kk = k;
¿Qué pasa si (kk & gt=num-1)?
u[2]=(y[kk+1] -y[kk])/(x[kk+1]-x[kk]);
¿Si? { (num==3)?
¿Y si? kk==0)? {?
u[3]=(y[2]-y[1])/(x[2]-x [1]);
u[4]= 2.0 * u[3]-u[2];
u[1]= 2.0 * u[2]-u[ 3];
u [0]= 2.0 * u[1]-u[2];?
}?
¿Y si? /p>
u[1]=(y[ 1]-y[0])/(x[1]-x[0]);
u[0]= 2.0 * u [1]-u[2];
u[3]= 2.0 * u[2]-u[1];
u[4]= 2.0 * u[3 ]-u[2];
}
}
¿Qué pasa si? {?
¿Qué pasa si ){?
u[3]=(y[kk] +2]-y[kk+1])/(x[kk+2]-x[kk+1]);
¿Y si (kk==1)?
u[1]=(y[1]-y[0])/(x[1]-x[0]);
u[0]= 2.0 * u[1]); -u[2];
¿Y si? (num==4)? u[4]= 2.0 * u[3 ]-u[2];
¿Y si? u[4]=(y[4]-y[3])/(x[4]-x[3]);
}
¿Y si? {?
u[1]= 2.0 * u[2]-u[3]
u[0]= 2.0 * u[1]-u[2];
u[4]=(y[3]-y[2])/(x[3]-x[2]);?
}
}
¿Y si? ¿si? (kk & gt=(núm-3))? {?
u[1]=(y[kk]-y[kk-1])/(x[kk]-x[kk
-1]);
¿Si? (kk==(núm-3))? {?
u[3]=(y[num-1]-y[num-2])/(x[num-1]-x[num-2]);
u[4]= 2.0 * u[3]-u[2];
¿Y si? (núm==4)? u[0]= 2.0 * u[1]-u[2];
¿Y si? u[0]=(y[kk-1]-y[kk-2])/(x[kk-1]-x[kk-2]);
}
¿Y si? {?
u[3]= 2.0 * u[2]-u[1]
u[4]= 2.0 * u[3]-u[2];
u[0]=(y[kk-1]-y[kk-2])/(x[kk-1]-x[kk-2]);
}?
}
¿Y si? {?
u[1]=(y[kk]-y[kk-1])/(x[kk]-x[kk-1]);
u [0]=(y[kk-1]-y[kk-2])/(x[kk-1]-x[kk-2]);
u[3]=(y [kk+2]-y[kk+1])/(x[kk+2]-x[kk+1]);
u[4]=(y[kk+3]- y[kk+2])/(x[kk+3]-x[kk+2]);?
}
}
mtr[0]= fabs(u[3]-u[2]);
mtr[ 1]= fabs(u[0]-u[1]);
¿Si? ((fabs(mtr[0])& lt;0.0000001)& amp;& amp(fabs(mtr[1])& lt;0.0000001))
p =(u[1]+u[ 2])/2.0;
¿Y si? p =(mtr[0]* u[1]+mtr[1]* u[2]/(mtr[0]+mtr[1]);
mtr[0]= fabs(u [3]-u[4]);
mtr[1]= fabs(u[2]-u[1]);
Si ((fabs(mtr[ 0 ])<0.0000001)&&(fabs(mtr[1])<0.0000001))
q =(u[2]+u[3])/2.0; p>¿Qué pasa si q =(mtr[0]* u[2]+mtr[1]* u[3]/(mtr[0]+mtr[1]);
mtr[0] ]= y[kk];
mtr[1]= p;
mtr[3]= x[kk+1]-x[kk]; p>mtr[2]=(3.0 * u[2]-2.0 * p-q)/mtr[3]
mtr[3]=(q+p-2.0 * u [2])/ (mtr[3]* mtr[3]);
¿Y si? (k & lt0)?{?
p = Pio-x[kk];
mtr[4]= mtr[0]+mtr[1]* p+mtr[2]* p * p+mtr[3]* p * p * p
}
Retorno;
}
principal()
{
Doble x[11 ]={3.0, 5,0, 8,0, 13,0, 17,0, 25,0, 27,0, 29,0, 31,0, 35,0, 39,0};
¿Doble y[11]={7,0, 10,0, 16,0, 17,0, 23,0, 18,0, 13,0, 6.0, 1.0, 0.0};
Aagente? {11,?x,?-1,?14.0,
?{0}};
¿Argenta? ab=? {11,?x,? y,? -1,?28.0,?{0}};
printf(" \n ");
Interpolación_akima(&aa);
printf( "x=%6.3f,?f(x)=%e\n ",aa.t,?aa.s[4]);
printf("mtr0=%e, ? mtr1= %e,? mtr3=%e\n ", aa.s[0], aa.s[2], aa . s[3]);
printf("\n");
Interpolación_akima(&ab);
printf("x=%6.3f,?f (x)=%e\n ",ab.t,?ab .s[ 4]);
printf("mtr0=%e,?mtr1=%e,?mtr2=%e, ? mtr3=%e\n ",ab.s[0],ab.s [1],ab.s[2],ab.s[3]);
printf(" \n ");
}
Implementación de interpolación spline cúbica
1, el programa es relativamente simple:
# include & ltiostream & gt
# include & ltiomanip & gt
¿Usar? ¿Espacio de nombres? estándar
const? int? Máx.
=?50;
¿Flotante? x[MÁX],? y[MÁX],? h[MAX];
¿Flotante? c[MÁX],? ¿Un [MÁXIMO]? fxym[MAX];
¿Flotador? f(int?x1,?int?x2,?int?x3){
¿Flotante? ¿respuesta? =?(y[x3]?-?y[x2])? /?(x[x3]?-?x[x2]);
¿Flotante? ¿b? =?(y[x2]?-?y[x1])? /?(x[x2]?-?x[x 1]);
¿Regresión? (a?-?b)/(x[x3]?-?x[x 1]);
}//Encuentra la diferencia
¿No es válido? cal_m(int?N){//Utilice el método de seguimiento para resolver el vector de momento flector m...
¿Flotante? b[MAX];
B[0]? =?c[0]? /?2;
for(int?i?=?1;?i?<?n;?i++)
B[i]? =?c[yo]? /?(2?-?a[I]* B[I-1]);
fxym[0]? =?fxym[0]? /?2;
Para (I?=?1;?I?& lt=?n;?i++)
fxym[i]? =?(fxym[i]?-?a[i]*fxym[i-1])? /?(2?-?a[I]* B[I-1]);
Para (I?=?n-1;?I?>=?0;?I-)
fxym[i]? =?fxym[yo]? -?b[I]* fxym[I+1];
}
¿No válido? Salida de impresión(int?n);
int? principal(){
int? n, yo;? ¿Ciel? ch;
Hacer {
cout & lt& lt"¿Por favor? ¿poner? ese? número? de? ese? punto:";
CIN> >n;
for (i?=?0;?i?<=?n;?i++){
cout <<"¿Por favor? poner? en? cout & lt& lt" ¿Por favor? ¿En? Y " & lt& ltI& lt& lt':';
CIN & gt;& gty[I];? //cout <<endl
}
For (I?=?0;?I?<?n;?I++)//Preguntar? ¿Tamaño de paso
h[i]? =?x[yo+1]? -?x[I];
cout & lt& lt"¿Por favor? Ingrese las condiciones de contorno\n? 1:? Se conocen las derivadas de primer orden en ambos extremos\n? 2: Las de segundo orden se conocen las derivadas en ambos extremos. ¿Sabes\n? Predeterminado: condiciones de contorno naturales\n ";
int? t;
¿Flotar? f0,? f 1;
CIN>& gtt;
Interruptor(t){
¿Caso? 1:cout<& lt"¿Por favor?Pon?in?Y0\ '?Y " & lt& ltn & lt& lt"\ ' \ n ";
CIN & gt;& gtf0 & gt& gtf
c[0]? =?1;? un]? =?1;
fxym[0]? =?6 *(y[1]?-?y[0])? /?(x[1]?-?x[0])? -?f0)? /?h[0];
fxym[n]? =?6*(f1?-?(y[n]?-?y[n-1])?/?(x[n]?-?x[n-1])?/?h[n-1 ];
Pausa;
Caso 2:cout &
lt;<"¿Por favor? ¿poner? ¿Y0\"? Y " & lt& ltn & lt& lt"\ " \ n
CIN & gt;& gtf0 & gt& gtf 1;
c[0]?=?a[n]? =?0;
fxym[0]? =?2 * f0? fxym[n]? =?2 * f 1;
Valor predeterminado: cout <<"No disponible\ n"; //Por determinar
};//Cambiar
Para (i?=?1;?i?<? n;?i++)
fxym[i]=?6?*?f(i-1,?i,?I+1);
Para (i?= ?1;?<?n;?i++) {
A[i]?/?(h[i]?+?h[I- 1]);
c[i] =?1?-?a [I];
}
a[n]? [n-1]?/?(h[n-1]?+?h[n]);
cal _ m(n);
cout & lt& lt” \nFunción de interpolación de spline cúbico de salida:\n";
Imprimir salida (n);
cout & lt& lt"¿Qué hacer? Y tú.
¿A dónde ir? ¿Hay alguno? ¿otro? ¿Probarlo? ¿si? :";
CIN & gt;& gtch;
}mientras(ch?==?Sí?||?ch?==?y');
¿Devolver?
}
¿Impresión no válida(int?n){
cout & lt& ltEstablecer precisión(6);
for(int?i?=?0;?i?<?n;?i++){
cout & lt& ltI+1 & lt;& lt": ?["<<x[ I]<<"?,?"<<x[I+1]<<"]\ n "<<"\t";
/*
cout & lt& ltfxym[I]/(6 * h[I])& lt;& lt"?*?(" & lt& ltx[I+1] & lt;& lt"?-?x)^3? +?"& lt& lt& lt& lt"?*?(x?-?"& lt& ltx[I]& lt;& lt")^3?+?"
& lt& lt(y[ i]? -?incógnita)? +?"
& lt& lt(y[i+1]?-?fxym[I+1]* h[I]* h[I]/6)/h[I]& lt; <"(x?-?"& lt& ltx[I]<<")\n";
cout & lt& ltendl*/
¿Flotar t? [I]/(6 * h[I]);
If (t?& gt?0)cout & lt;& ltt & lt& lt" *(" & lt;& ltx [I+ 1]& lt;& lt"?-?x)^3";
¿Qué más? cout & lt& lt-t & lt"*(x?-?"& lt& ltx[I+1 ]& lt;& lt")^3";
t? =?fxym[I+1]/(6 * h[I]);
if (t? & gt?0)cout & lt;& lt"?+?"& lt& ltt & lt& lt"*(x?-?"& lt& ltx[I]& lt;& lt")^ 3";
¿Y si? cout & lt& lt"?-?"& lt& lt-t & lt;& lt"*(x?-?"& lt& ltx[I]& lt;& lt")^3" ;
cout & lt& lt"\ n \ t";
t? =?(y[i]?-?fxym[I]* h [I]* h[ I]/6)/h[I];
If (t?& gt?0)cout & lt;& lt"+?"& lt& ltt & lt& lt" *("& lt; & ltx[I+1]& lt;& lt"?-?x)";
¿En caso contrario? cout & lt& lt"-?"& lt& lt-t & lt;& lt" *( " & lt;& ltx[I+1]& lt;& lt"?-?x)";
t? =?(y[i+1]? -?fxym[I+1] ]* h[I]* h[I]/6)/h[I];
Si (t?& gt?0)cout & lt;& lt" ?+?"& lt& ltt & lt& lt"*(x?-?"& lt& ltx[I]& lt;& lt")";
¿De lo contrario cout & lt& lt"?- ?"<&
lt-t & lt;& lt"*(x?-?"& lt& ltx[I]& lt;& lt")";
cout & lt& ltendl & lt& ltendl
}
cout & lt& ltendl
}
2. El programa es más complicado:
(01., 02. , 03. Espere. Hay números de declaración frente al programa, elimínelos uno por uno en la aplicación real) 01. /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
02.#¿Incluir? & ltstdio.h & gt
03.//////////////////////////////////// / /////////////////////////////////////////////////
04.#defineMAXNUM50? //El número máximo de intervalos de datos spline es 50.
05.typedef? estructura? SPLINE // Define una estructura spline para almacenar toda la información de una spline.
06.{?//Inicializar entrada de datos
07.? ¿flotar? x[MAXNUM+1]; //Almacena las coordenadas X de los puntos en el spline, hasta 51 puntos.
08.? ¿flotar? y[MAXNUM+1]; //Almacenamiento de coordenadas Y de puntos en el spline, hasta 51 puntos.
09.? ¿No firmado? int? Número de puntos;? // ¿Almacenar real en spline? ¿punto? Cantidad
10.? ¿flotar? comenzar_k 1;? //La información de la primera derivada del punto de partida
11.? ¿flotar? end_k1;? //La información de la primera derivada del punto final
12.? //¿flotar? comenzar _ k2//La información de la segunda derivada del punto de partida
13.? //¿flotar? end_k2? //Información de la segunda derivada del punto final
14.? //Función spline calculada S(x)
15.? ¿flotar? k 1[MAXNUM+1]; //Información derivada de primer orden de todos los puntos
16.? ¿flotar? k2[MAXNUM+1]; //Información de la segunda derivada de todos los puntos
17.? // Hay 50 segmentos en 51 puntos y func [] almacena el coeficiente de función de cada segmento.
18.? ¿flotar? a3[MAXNUM], a 1[MAXNUM];
19.? ¿flotar? b3[MAXNUM], b 1[MAXNUM];
20.? //¿Cuál es la forma de la función por partes? Seis)? =?a3[yo]? *?{x(yo+1)? -?x}^3+? a1[yo]? *?{x(yo+1)? -?incógnita}? +
21.? //b3[i]? *?{¿incógnita? -?x(i)}^3? +?b1[yo]? *?{¿incógnita? -?x(i)}
22.? //xi es el valor de x[i], xi_1 es el valor de x[i+1].
23.}SPLINE, *pSPLINE
24.typedef? int? Resultado; // Devuelve el estado del resultado de la ejecución de la función. A continuación se muestran opciones de devolución específicas.
25.#ifndef? Real
26.#¿Definición? ¿En realidad? 1
27.#endif
28.#ifndef? Incorrecto
29.#¿Definición? ¿Falso? -1
30.#endif
31.#ifndef? Vacío
32.#¿Definición? ¿NULO? 0
33.#endif
34.#ifndef? Crimen
35.#¿Definición? Error 2
36.#endif
37.//////////////////////////// // ///////////////////////////////////////////////// ////// ////
38./*============================== ======= ============================================ =?
39.***?Nombre de la función:? ¿Spline3()?
40.***?Descripción de la función:? ¿Diferencia de spline cúbica completa, donde se utiliza el método de búsqueda para resolver la matriz m?
41.***?Parámetros de participación:? (PSpLine) X[], Y[], NUM, BEGIN_K1, END_K1 en pSPLINE)¿Puntero de estructura de pLine?
42.***?Parámetros de exportación:? (Línea PSP)Parámetros de función en la línea PSP)PLINE estructura puntero pLine?
43.***?Parámetros de retorno:? Devuelve el estado de los resultados de ejecución del programa. ¿En realidad? ¿aún? ¿Falso?
44.========================================== = ========================================*/
45 . ¿resultado? Spline3(pSPLINE?pLine)
46.{
47.? ¿flotar? ¿H[NÚMÁXIMO]? =?{0};? //El tamaño del paso entre celdas
48.? ¿flotar? ¿Fi[MÁXNUM]? =?{0};? //Cantidad intermedia
49.? ¿flotar? ¿U[MÁXNUM+1]? =?{0};//Cantidad intermedia
50.? ¿flotar? ¿UN[MÁXNUM+1]? =?{0};//Cantidad intermedia
51.? ¿flotar? ¿D[NÚMÁXIMO+1]? =?{0};//Cantidad intermedia
52.? ¿flotar? ¿M[NÚMÁXIMO+1]? =?{0};//Matriz M
53.? ¿flotar? B[NÚMÁXIMO+1]? =?{0};//Persiguiendo la cantidad intermedia
54.? ¿flotar? ¿Y[MÁXNUM+1]? =?{0};//Persiguiendo variables intermedias
55.? int? ¿I? =?0;
56.? ////////////////////Calcular parámetros intermedios.
57.? if((pLine->punto_número?<?3)?||?(pLine->;punto_número?>?MAXNUM?+?1))
58.? {
¿Volver? ¿ERRAR? //El número de puntos de datos de entrada es demasiado pequeño o demasiado.
60.? }
61.? para (i?=?0;i?<=?pLine->;dot_number?-?2;i++)
62.? {//Encontrar H[i]
63.H[i]? =?pLínea->x[i+1]? -?pLine->;x[I];
64.Fi[i]? =?(pLínea->y[i+1]?-?pLínea->y[i])? /?Hola];? //Encontrar F[x(i),x(i+1)]
65.? }
66.? Para (I?=?1;I?<=?pLine->;dot_number?-?2;i++)
67.? {//Encontrar U[i] y A[i] y D[i]
68.U[i]? =?H[i-1]? /?(H[i-1]?+?h[I]);
69.A[I]? =?H[yo]? /?(H[i-1]?+?h[I]);
70.D[i]? =?6?*?(Fi[i]?-?Fi[i-1])? /?(H[i-1]?+?h[I]);
71.? }
72.? //Si la condición de frontera es 1, entonces
73.? U[i]? =?1;
74.? ¿Un[0]? =?1;
75.? D[0]? =?6?*?(Fi[0]?-?pLine->begin_k1)? /?h[0];
76.? D[yo]? =?6?*?(pLine->end_k1?-?Fi[i-1])? /?h[I-1];
77.? //Si la condición de contorno es la número 2, entonces
78.? //U[yo]? =?0;
79.? //¿A[0]? =?0;
80.? //D[0]? =?2?*?comenzar _ k2
81.? //D[yo]? =?2?*?end _ k2
82.? //////////////////////Usando el método de seguimiento para resolver la matriz M.
83.? B[0]? =?A[0]? /?2;
84.? Para (I?=?1;I?<=?pLine->;dot_number?-?2;i++)
85.? {
86.B[i]? =?¿Un[yo]? /?(2?-?U[i]?*?b[I-1]);
87.? }
88.? ¿Y[0]? =?D[0]? /?2;
89.? Para (I?=?1;I?<=?pLine->;dot_number?-?1;i++)
90.? {
91.Y[i]? =?(D[i]?-?U[i]?*?Y[i-1])? /?(2?-?U[i]?*?b[I-1]);
92.? }
93.? m[pLine->Número_punto? -?1]?=?y[pLine->Número_punto? -?1];
94.? Para (i?=?pLine->;dot_number?-?1;i?>?0;i-)
95.? {
96.M[i-1]? =?Y[i-1]? -?B[i-1]? *?m[Yo];
97.? }
98.? /////////////////////////////////////////////////// //// //////////////////////////////////////////
99.? para (i?=?0;i?<=?pLine->;dot_number?-?2;i++)
100.? {
101.pLine->a3[i]? =?M[yo]? /?(6?*?h[I]);
102.pLine->a1[i]? =?(pLine->;y[i]?-?M[i]?*?H[i]?*?H[i]?/?6)?/?h[I];
103.pLine->b3[i]? =?M[i+1]? /?(6?*?h[I]);
104.pLine->b1[i]? =?(pLínea->;y[i+1]?-?M[i+1]?*?H[i]?*?H[i]?/?6)?/H[I];
105.? }
106.? ¿devolver? Verdadero;
107.}
108.///////////////////////////// // ///////////////////////////////////////////////// ////// ///
109. línea 1;
110.pSPLINE? pLínea1? =?& ampline 1;
111.//////////////////////////////////// / ///////////////////////////////////////////////// /
112.main()
113.{
114.? línea1.x[0]? =?27,7;
115.? línea1.x[1]? =?28;
116.? línea1.x[2]? =?29;
117.? línea1.x[3]? =?30;
118.? línea1.y[0]? =?4.1;
119.? línea1.y[1]? =?4.3;
120.? línea1.y[2]? =?4.1;
121.? línea1.y[3]? =?3.0;
122.? línea1.punto_num? =?4;
123.? línea1.begin_k1? =?3.0;
124.? yo
ine1.end_k1? =?-4.0;
125.? spline 3(pline 1);
126.? ¿devolver? 0;
127.}
128.////////////////////////////// / ///////////////////////////////////////////////// ///// ///