integrales simbólicas y numéricas de matlab

En MATLAB, int se usa principalmente para la integración simbólica y trapz, dblquad, quad, quad8, etc. se usan para la integración numérica.

int(s) La integral indefinida de la expresión simbólica s

int(s, x) La integral indefinida de la expresión simbólica s con respecto a la variable x

int( s, a, b) La integral definida de la expresión simbólica s, a, b son los límites superior e inferior de la integral respectivamente

int(s, x, a, b) La integral definida de la expresión simbólica s con respecto a la variable x Integración, a, b son los límites superior e inferior de la integral respectivamente

método de integración trapezoidal trapz(x, y), x representa la discretizada vector del intervalo de integración, y es un vector de la misma dimensión que x, lo que significa Integrade, z devuelve el valor integral.

quad8('fun', a, b, tol) Integración numérica con tamaño de paso variable, fun representa el nombre de la función M del integrando, a, b son los límites superior e inferior de la integración respectivamente, tol es la precisión, falta La provincia es 1e-3.

fblquad('fun', a, b, c, d) Integración numérica doble en un área rectangular, fun representa el nombre de la función M del integrando, a, b son respectivamente Los límites superior e inferior de x, cyd son los límites superior e inferior de y respectivamente.

Ejemplo 1 Calcular integral doble

Primero escribe cuatro Archivos de funciones M,

Archivo de algoritmo integral doble dblquad2.m

función S=dblquad2(f_name, a, b, c_lo, d_hi, m, n)

donde f_name es la cadena de caracteres de la función integrando, 'c_lo' y 'd_hi' son las funciones de límite inferior y superior de y, ambas son funciones escalares de x; a, b son el límite inferior y el límite superior de x respectivamente; , n son fracciones iguales en las direcciones x e y respectivamente (falta El valor predeterminado es 100).

if narginlt; n=100; m=100; end

if mlt; 2|nlt; 2

error('Número de intervalos no válido'); p> mpt=m 1; hx=(b-a)/m; x=a (0: m)*hx

para i=1: mpt

ylo=feval_r( c_lo, x(i)); yhi=feval_r(d_hi, x (i));

hy=(yhi-ylo)/n;

para k=1: n 1 y(i,k)=ylo (k-1)* hy; f(i,k)=feval_r(f_name,x(i),y(i,k)); (i)=trapz(y(i,:),f( i, :));

fin

S=trapz(x, G);

Función integral eg3_fun.m

función z=eg3_fun(x, y)

z=1 x y;

Función integral de límite inferior eg3_low.m

función y=eg3_low(x)

y=-sqrt(1-x^2);

Función de límite superior integral eg3_up.m

función y=eg3_up(x)

y=sqrt(1-x^2);

Después de guardar, use el código MATLAB en la ventana de comandos:

gt; gt; clear;

gt ;gt;dblquad2('eg3_fun',-1,1,'eg3_low','eg3_up')

El resultado es

ans =3.1383

Para obtener una solución numérica más precisa, el intervalo debe ser más refinado. Por ejemplo, las direcciones xey se dividen equitativamente en 1000 puntos. Código MATLAB:

gt; gt; dblquad2('eg3_fun', -1, 1, 'eg3_low', 'eg3_up', 1000, 1000)

respuesta = 3,1415.

Este problema también se puede resolver usando símbolos int.

gt; =int (1 x y, y, -sqrt(1-x^2), sqrt(1-x^2));

gt; int(iy, x, -1, 1)

El resultado es

ans =pi

Ejemplo 2 de cálculo quad8 de integral definida

Función M fun1.m

función y=fun1(x)

y=x.^4;

Después de guardar, use el código MATLAB en la ventana de comandos:

gt; gt; claro;

gt;gt;quad8('diversión1',-2,2)

gt;gt;vpa(quad8('diversión1',-2 ,2),10) a El resultado se muestra con 10 cifras significativas

El resultado es

ans =12.8000

ans =12.80000000

Para la integración numérica con tamaño de paso variable, se usan comúnmente Hay dos comandos, quad y quad8. Quad usa el método de Simpson de paso adaptativo y quad8 usa el método de Newton-Cotes de paso adaptativo de 8 órdenes. solo tiene mayor precisión, pero también puede manejar convergencias falsas e integrales singulares falsas. Tiene cierta adaptabilidad, pero quad es pobre.

Código de programa MATLAB del método integral de Roberg

función [I. , paso]=Roberg(f, a, b, eps )

if(nargin==3)

eps=1.0e-4;

fin ;

M=1;

tol=10;

k=0;

T=zeros(1,1);

h=b-a;

p>

T(1, 1)=(h/2)*(subs(sym(f), findsym(f)), a) subs(sym(f), findsym(f)) , b));

mientras tolgt; eps

k=k 1;

h =h/2;

Q= 0;

para i=1: M

x=a h*(2*i-1); p>

Q=Q subs(sym(f) , findsym(sym(f)),x);

end

T(k 1, 1)=T (k, 1)/2 h*Q;

M=2*M;

para j=1：k

T(k 1,j 1)=T(k 1,j) (T(k 1, j)-T(k, j))/(4^j-1);

fin

tol=abs(T(k 1, j 1)-T (k, j));

end

I=T(k 1, k 1); >

step=k;

Método adaptativo para código de programa MATLAB integral

función I=SmartSimpson(f, a, b, eps)

if (nargin==3)

eps=1.0e-4;

fin;

e=5*eps;

I =SubSmartSimpson(f,a,b,e);

función q=SubSmartSimpson(f, a, b, eps)

QA=IntSimpson(f

, a, b, 1, eps);

QLeft=IntSimpson(f, a, (a b)/2, 1, eps);

QRight=IntSimpson(f, ( a b)/2, b, 1, eps);

if(abs(QLeft QRight-QA)lt;=eps)

q=QA;

else

q=SubSmartSimpson(f, a, (a b)/2, eps) SubSmartSimpson(f, (a b)/2, b, eps

fin

Código MATLAB del método integral Wilson θ para análisis de respuesta de vibración lineal

ver también

contácteme matlabsky@gmail.com

2010-02- 26 16:52:12

clc

clear

Parámetros de la ecuación de movimiento estructural

M=1500000 ;

K=3700000;

C=470000;

Parámetro de Wilson θ

theta=1,4;

dt=0.02; Intervalo de tiempo

tau=dt*theta;

Procesamiento de datos

eqd=load('acc_ElCentro_0.34g_0.02s.txt') ; Excitación de aceleración, la primera columna es el tiempo, la segunda columna es la aceleración

n=size(eqd, 1);

t=0: dt: (n-1)* dt;

xg=eqd(:,2)*9.8; Aceleración del proceso

dxg=diff(xg)*theta

F=- M*; xg;

D2x aceleración; Dx velocidad; x desplazamiento

D2x=zeros(n, 1);

Dx=zeros(n, 1) ;

x=zeros(n,1);

para i=1：n-1

K_ba=K 3/tau*C 6/tau ^2 *M;

dF_ba=-M*dxg(i) (M*6/tau 3*C)*Dx(i) (3*M tau/2*C)*D2x(i );

dx=dF_ba/K_ba;

dD2x=(dx*6/tau^2-Dx(i)*6/tau-3*D2x(i))/ theta;

D2x(i 1)=D2x(i)dD2x;

Dx(i 1)=Dx(i)D2x(i)*dt dD2x/2*dt

x(i 1)=x(i) Dx(i)*dt D2x(i)*dt^2/2 dD2x/6*dt^2

fin

subtrama(311)

trama(t, x) desplazamiento

subtrama(312)

trama(t, Dx) velocidad

subplot(313)

aceleración de plot(t, D2x)

El código del programa matlab del algoritmo de Runge-Kutta de cuarto orden para resolver ecuaciones diferenciales ordinarias

función [x, y] = MyRunge_Kutta(diversión, x0, xt, y0, PointNum, varargin)

El método Runge-Kutta resuelve ecuaciones diferenciales de la forma y’(t) = f(x, y(x))

Este programa puede resolver ecuaciones diferenciales de orden superior. Simplemente escriba su forma como la forma vectorial de la ecuación diferencial anterior.

El rango de x es [x0, xt], el valor inicial es y0, PointNum es el número de puntos discretos y varargin es opcional. elemento de entrada Puede pasar los parámetros apropiados a la función f(x, y)

if nargin lt 4 | PointNum lt;= 0

PointNum= 100;

fin

si nargin lt; 3

y0 = 0

fin

y(1,:) = y0; (:)'; El valor inicial se almacena como un vector de fila. Form

h = (xt-x0)/(PointNum-1); 0: PointNum]'*h; Obtener el valor del vector x

p>

para k = 1: cálculo iterativo de PointNum

f1 = h*feval_r(fun, x(k ), y(k,:), varargin {:});

f1 = f1(:)'; obtiene k1 en la fórmula

f2 = h*feval_r(fun, x(k) h/2, y(k,:) f1/2, varargin{ :});

f2 = f2(:)'; Obtener k2 en la fórmula

f3 = h*feval_r(fun,x(k) h/2,y(k, :) f2/2, varargin{:});

f3 = f3(:)'; en la fórmula

f4 = h*feval_r(fun, x(k) h, y(k,:) f3, varargin{:});

f4 = f4(: )'; Obtenga k4 en la fórmula

y(k 1,:) = y(k,:) (f1 2*(f2 f3) f4)/6;