código fuente spline
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- gt;n;? k = AP- gt;k;
Pio = AP- gt;t;? mtr=ap->.
s;?
x = AP- gt;x;? y = AP- gt;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]);
Regresar;
}
¿Si? (k lt0)?{?
Si? (pio lt=x[1])? si? {?
kk = 1;? m = num
¿Cuándo? (((kk-m)!= 1); amp((kk-m) ! =- 1))?{?
l =(kk m)/2;
¿Y si? (pio ltx[l-1])? = l;
}?
kk-;
}
}
¿Qué pasa si kk = k ;
¿Qué pasa si (kk gt=num-1)? kk = num-2;
u[2]=(y[ kk 1]-y[kk])/ (x[kk 1]-x[kk]);
¿Si? (num==3)? {?
¿Si? /p>
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];?
}?
¿Qué pasa si {?
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? (kk lt=1){?
u [3]=(y[kk 2] -y[kk 1])/(x[kk 2]-x[kk 1]);
¿Y si (kk==1)? (y[1]-y[0])/(x[1]-x[0]);
u[0]= 2.0 * u [1]-u[2];
¿Qué pasa si? (num==4)? u[4]= 2.0 * u[3]-u[2];
De lo contrario, ¿tela de lana? 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]) ) lt; 0.0000001) amp; amp(fabs(mtr[1]) lt; 0.0000001))
q =(u[2] u[3])/2.0;
¿De lo contrario 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];
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;
}
Regresar;
}
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, 3,0, 1,0, 0,0};
¿Argenta? aa=? {11,?x,? y,? -1,?14.0,?{0}};
¿Argenta? ab=? {11,?x,? y,? -1,?28.0,?{0}};
printf("\n");
Interpolación_akima(amp;aa);
printf( "x=6.3f,?f(x)=e\n ",aa.t,?aa.s[4]);
printf("mtr0=e,?mtr1=e ,? mtr2=e,? mtr3=e\n ", aa.s[0], aa.s[1], aa.s[2], aa . s[3]);
printf( "\n");
Interpolación_akima(amp;ab);
printf("x=6.3f,?f(x)=e\n", ab.t, ? ab . s[1], ab.s[2], ab.s[3]);
printf(" \ n ");
}
Implementación de la 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];
¿Flotar? 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?lt?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? gt=?0;?I-)
fxym[i]? =?fxym[yo]? -?b[I]* fxym[I 1];
}
¿No es válido? Salida de impresión(int?n);
int? principal(){
int? n, yo;? ¿Ciel? ch;
do {
cout lt lt"¿Por favor? ¿ponga? ese? número? de? ese? punto: ";
CIN gt; gtn;
for (i?=?0;?i? lt=?n;?i){
cout lt lt"¿Por favor? ¿poner? " ? lt ltIlt lt':';
CIN gty[I];? //cout lt; ltendl
}
For (I?=?0;?I? lt?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 derivadas de segundo orden en ambos extremos son conocidos \n?Predeterminado: condiciones de contorno naturales\n";
int? t;
¿Flotar? f0,? f 1;
CIN gt; gtt;
Interruptor(t){
¿Caso? 1: coutlt lt"¿Por favor? poner? en? Y0\ '?Y " lt ltn lt lt"\ ' \ n ";
CIN gtf0 gt gtf 1;
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];
Romper;
¿Caso? 2: cout lt; 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 lt "No disponible\n"; / TBD
}; // Cambiar
Para (i?=?1;?i? lt?n;?i)
fxym[i] ?=?6?*?f(i-1,?I,?I 1);
Para (I?=?1;?I?lt? n;?i){
A[i]?=?h[i-1]?/?(h[i]??h[I-1]);
c[i] =?1 ?-?a[I];
}
a[n]? =?h[n-1]? [n-1]??h[n]);
cal _ m(n);
cout lt lt"\nFunción de interpolación spline cúbica 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 0;
}
Impresión no válida(int?n){
cout lt ltset precision(6);
p>for(int?i?=?0;?i?lt?n;?i){
cout lt ltI 1 lt;:?[" ltx[I ] lt; ; lt"?,?" lt ltx[I 1] lt; lt"]\ n " lt"\ t"; ]/(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]?-?fxym[ I]* h[I]* h[I]/6)/h[I] lt; lt"?*?(" lt ltx[I 1] lt; lt"?-?x)? ?"
lt lt(y[i 1]?-?fxym[I 1]* h[I]* h[I]/6)/h[I] lt; lt"(x? -?" lt ltx[I] lt; lt")\n";
cout lt ltendl*/
Float?t?=?fxym[I]/(6 * h[I]);
if (t? gt? 0)cout lt; ltt lt lt" *(" lt; ltx[I 1] lt; lt"?-?x)^3" ;
¿Qué pasa si cout lt lt-t lt; lt "*(x?-?" lt ltx[I 1] lt; lt")^3"
t ? =?fxym[I 1]/(6 * h[I]);
if (t? gt? 0)cout lt"? ?" " lt ltx[I] lt; lt")^3";
¿Qué más? 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];
Si (t? gt? 0)cout lt" lt lt 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];
if (t? gt?0)cout lt; lt"? ?" lt")";
¿Qué más? cout lt lt"?-?"
I] lt; lt")";
cout lt ltendl lt ltendl
}
cout lt ltendl
}
2. El programa es relativamente complicado:
(01., 02., 03., etc. Hay números de declaración delante del 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]; //Almacenamiento de coordenadas X de 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 lo 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? final_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(i 1)? -?x}^3? a1[yo]? *?{x(i 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[NÚMÁXIMO 1]? =?{0};//Cantidad intermedia
50.? ¿flotar? ¿UN[MÁXIMO 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};//Ponerse al día con la cantidad intermedia
54.? ¿flotar? ¿Y[MÁXNUMX 1]? =?{0};//Ponernos al día con las variables intermedias
55.? int? ¿I? =?0;
56.? ////////////////////Calcular parámetros intermedios.
57.? if((pLine- gt;point_number?lt?3)?||?(pLine->;point_number?gt?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?lt=?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?lt=?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[yo]? =?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[i]? =?0;
79.? //¿A[0]? =?0;
80.? //D[0]? =?2?*?comenzar _ k2
81.? //D[yo]? =?2?*?end _ k2
82.? //////////////////////Uso del método de seguimiento para resolver la matriz M.
83.? B[0]? =?A[0]? /?2;
84.? Para (i?=?1;i?lt=?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?lt=?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-gt;Número_punto? -?1]?=?y[pLine-gt;Número_punto? -?1];
94.? Para (i?=?pLine->;dot_number?-?1;i?gt?0;i-)
95.? {
96.M[i-1]? =?Y[i-1]? -?B[i-1]? *?m[Yo];
97.? }
98.? /////////////////////////////////////////////////// //// //////////////////////////////////////////
99.? Para (i?=?0;i?lt=?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[yo 1]? /?(6?*?h[I]);
104.pLine->b1[i]? =?(pLine->;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? =? amplina 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.? li
ne1.y[3]? =?3.0;
122.? línea1.punto_num? =?4;
123.? línea1.begin_k1? =?3.0;
124.? línea1.end_k1? =?-4.0;
125.? spline 3(pline 1);
126.? ¿devolver? 0;
127.}
128.////////////////////////////// // ///////////////////////////////////////////////// ////// ///