Documente Academic
Documente Profesional
Documente Cultură
1
b=c;
} else {
a=c;
}
}
while(Math.abs(f(c))>eps);
/// daca |f(c)| < eps atunci se scrie radacina
System.out.println("Metoda injumatatirii
intervalului");
System.out.println("Radacina = "+Double.toString(c));
} else {
System.out.println("Interval ales gresit!!!");
}
}
}
2. Metoda coardei variabile
y − f ( a ) f ( b) − f ( a )
=
x− a b− a
y = 0
/**
* @param args
2
*/
public static double f(double x){
return Math.log(x)+x;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
/// se declara variabilele a, b, c, eps
double a = 0.001, b=2, c, eps = 1e-6;
if(f(a)*f(b) < 0){
do{
/// se calculeaza c=(a+b)/2
c = a-f(a)*(b-a)/f(b)-f(a);
3
Rezolvarea unui sistem de ecuaţii liniare
4
1 a "
. a x1 b
" "
12
1n
"
1
"
0 1 . a x2 b
. . ⋅ 2n
= 2
. . . .
0 0 . ann xn bn
" "
5
In aceste relaţii a[i][j] reprezintă elementele matricii A.
După ce matricea coeficienţilor a fost transformată se calculează
vectorul necunoscutelor X în ordine descrescătoare cu relaţia:
n
xi = bi − ∑a x ;
j = i +1
ij j i = n,1
6
for(i=pas+1; i<n; i++)
m[i][pas] = -a[i][pas] / a[pas][pas];
// se inmulteste matricea m cu a
for(i=0; i<n; i++)
for(j=0; j<n; j++){
a_aux[i][j] = 0;
for(k=0; k<n; k++)
a_aux[i][j] += m[i][k] * a[k][j];
}
// rezultatul se va atribui lui a
for(i=0; i<n; i++)
for(j=0; j<n; j++)
a[i][j] = a_aux[i][j];
// se inmulteste matricea m cu b
for(i=0; i<n; i++){
b_aux[i] = 0;
for(k=0; k<n; k++)
b_aux[i] += m[i][k] * b[k];
}
// rezultatul se va atribui lui b
for(i=0; i<n; i++)
b[i] = b_aux[i];
// se trece la pasul urmator
}
7
Interpolarea liniară a unei funcţii
8
Cu această relaţie se poate calcula valoarea y pentru orice punct x
aflat între cele două puncte x1 şi x2:
x − x1
y = y1 + ⋅ ( y 2 − y1 )
x 2 − x1
Interpolarea Spline
La interpolarea Lagrange gradul polinomului care se obţine este cu atât mai
mare cu cât numărul de puncte este mai mare. Aceasta implică un număr
mare de calcule. Spre deosebire de polinoamele Lagrange, în cazul funcţiilor
Spline se lucrează cu un polinom de gradul trei pentru a accelera viteza de
calcul.
Forma generală a unui polinom de gradul III este: P(t) = at3 + bt2 + ct
+ d. Acest lucru se poate scrie sub formă matricială astfel:
t 3
2
t
P =[ a b c d] ⋅
t
1
9
In plan un punct este reprezentat prin coordonatele x(t) şi y(t), iar în
spaţiu intervine şi coordonata z(t). In continuare se va lucra doar în funcţie
de parametrul t, urmând ca în final să se treacă la coordonatele x şi y. Se pot
aranja lucrurile astfel încât pentru cele două puncte de la capetele unui
interval să se obţină o reprezentare astfel: pentru primul punct să-i
corespundă lui t valoarea 0, iar pentru al doilea punct să-i corespundă lui t
valoarea 1.
Coeficienţii a, b, c, d se obţin din 4 condiţii şi anume la capetele
intervalului se dau şi valorile coordonatelor punctelor şi derivatele, pentru a
se obţine racordarea graficului. Aceasta înseamnă că se cunosc P(0), P(1),
P'(0) şi P'(1), unde P'(t) este polinomul derivat: P'(t) = 3at2 + 2bt + c. Din
cele patru condiţii se obţin coeficienţii:
2 −3 0 1
−2 3 0 0
[a b c d ] = [ P ( 0) P (1) P ′( 0) P ′(1) ]
1 −2 1
0
1 −1 0 0
2 −3 0 1 t 3
−2 3 0 0 2
P ( t ) = [ P ( 0) P (1) P ′( 0) P ′(1) ] ⋅ ⋅ t
1 −2 1 0 t
1 −1 0 0 1
In practică această relaţie se foloseşte astfel:
• se dau punctele de la marginea intervalului, adică P(0) şi P(1)
• se dau sau se calculează derivatele la capetele intervalului P'(0) şi P'(1)
• se alege un număr de puncte în care vrem să interpolăm funcţia dându-i
valori echidistante lui t în intervalul [0,1]
• Se calculează polinomul P(t) în aceste puncte
10
Dacă avem mai multe intervale, se aplică acelaşi algoritm pentru
fiecare interval luat în parte.
La reprezentarea în plan polinomul P este de fapt un vector cu două
componente x(t) şi y(t), iar la reprezentarea în spaţiu este un vector cu trei
componente x(t), y(t) şi z(t).
Pentru calculul derivatei într-un punct se consideră dreptele care se
obţin unind punctul respectiv cu cele două puncte vecine, din stânga şi din
dreapta. Se face media unghiurilor acestor drepte cu axa Ox orizontală,
obţinându-se unghiul α . Componentele polinomului derivat vor fi x' =
k·cos(α ) şi y' = k·sin (α ), unde k se alege în urma unor încercări. Valorile
uzuale sunt între 1 şi 3. (Observaţie: pentru valoarea k=0 se obţine chiar
interpolarea liniară). Pentru punctele extreme vom avea doar un singur
vecin, şi se ia unghiul respectiv.
11
int nrPuncte;
public Spline(){
double[][] M1 = new double[2][4];
double[][] M2 = {{2, -3, 0, 1},
{-2, 3, 0, 0},
{1, -2, 1, 0},
{1, -1, 0, 0}};
double[] M3 = new double[4];
double[] M23 = new double[4];
double xx, yy;
int crt=0;
12
M3[0] = t*t*t; M3[1] = t*t; M3[2] = t; M3[3]
= 1;
}
Desenarea graficului functiei
package interpolare;
import java.awt.*;
import javax.swing.*;
/**
*
*/
private static final long serialVersionUID = 1235237784941049108L;
int Xmax = 800;
int Ymax = 600;
int XScale = 50;
int YScale = 50;
public GraficSpline(){
13
this.setSize(Xmax, Ymax);
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
GraficSpline grSp = new GraficSpline();
grSp.setVisible(true);
}
14
Integrarea numerică
Si = ( xi +1 − xi ) ⋅ f ( xi )
15
mai sus se va înlocui f(xi) cu f(xi+1). O altă variantă este cea cu valoarea de la
mijlocul intervalului f((xi+xi+1)/2). Aceste variante se pot vedea în figura de
mai jos.
f ( xi ) + f ( xi +1 )
Si = ( xi +1 − xi ) ⋅
2
In acest caz eroarea de aproximare a integralei este mai mică decât la metoda
dreptunghiurilor. Dacă se aproximează graficul funcţiei pe intervalul [xi, xi+1]
cu o parabolă se obţine metoda lui Simpson, caz în care formula de calcul
este:
xi + xi +1
f ( xi ) + 2 f ( ) + f ( xi +1 )
Si = ( xi +1 − xi ) ⋅ 2
4
16
La formula lui Simpson eroarea de aproximare este cea mai mică.
/**
* @param args
*/
17
System.out.println("Rezultatul 2 = "+
Double.toString(integ2));
System.out.println("Rezultatul corectat = "+
Double.toString(integrala + (integrala - integ2)/3));
}}
18
8. Se scrie valoarea lui yi+1.
9. Se închide ciclul.
package ecuatiidiferentiale;
/**
* @param args
*/
int n=100;
static double[] xArray = new double[100];
static double[] yArray = new double[100];
public RungeKutta(){
int i;
double t = 0, tf = 0.1, y=0, h, k1, k2, k3, k4;
h = (tf - t) / n;
for(i=0; i<n; i++){
t = i*h;
k1 = f(t, y);
k2 = f(t+h/2, y+k1*h/2);
k3 = f(t+h/2, y+k2*h/2);
k4 = f(t+h, y+k3*h);
y += h/6 * (k1+2*k2+2*k3+k4);
xArray[i] = t+h;
yArray[i] = y;
}
double getXmax(){
double xmax = 0;
for(int i=0; i<n; i++){
if(xmax < xArray[i]) xmax = xArray[i];
}
return xmax;
}
double getXmin(){
double xmin = 0;
for(int i=0; i<n; i++){
if(xmin > xArray[i]) xmin = xArray[i];
}
return xmin;
}
19
double getYmax(){
double ymax = 0;
for(int i=0; i<n; i++){
if(ymax < yArray[i]) ymax = yArray[i];
}
return ymax;
}
double getYmin(){
double ymin = 0;
for(int i=0; i<n; i++){
if(ymin > yArray[i]) ymin = yArray[i];
}
return ymin;
}
System.out.println(Double.toString(RungeKutta.xArray[i])
+"\t"+Double.toString(RungeKutta.yArray[i]));
}
}
import java.awt.*;
import javax.swing.*;
/**
* @param args
*/
private static final long serialVersionUID = 1235237784941049199L;
int Xmax = 800;
int Ymax = 600;
int XScale = 500;
int YScale = 250;
int xOffset = 150;
int yOffset = 300;
public GraficRungeKutta(){
this.setSize(Xmax, Ymax);
}
20
g.drawLine(50, yOffset-10, 750, yOffset-10);
g.drawLine(155, 50, 155, 550);
int x0, y0, x1, y1;
double xmax = rk.getXmax();
double ymax = rk.getYmax();
double ymin = rk.getYmin();
if(ymax < Math.abs(ymin)) ymax = Math.abs(ymin);
for(int i=0; i<(rk.n-1); i++){
x0 = xOffset + (int)
(XScale*RungeKutta.xArray[i]/xmax);
y0 = yOffset - (int)
(YScale*RungeKutta.yArray[i]/ymax);
x1 = xOffset + (int)
(XScale*RungeKutta.xArray[i+1]/xmax);
y1 = yOffset - (int)
(YScale*RungeKutta.yArray[i+1]/ymax);
g.drawLine(x0, y0, x1, y1);
}
}
21
Rezolvarea sistemelor de ecuaţii diferenţiale prin metoda Runge-Kutta
dy i
= f i (t , y1 , y 2 ,.., yn ), i = 1.. n
dt
h
yi +1 = yi + ( k1 + 2 k 2 + 2 k 3 + k 4 )
6
mărimile y şi k1, k2, k3, k4 vor fi nişte vectori cu n valori:
k 1, j = f j ( t i , yi , j )
h h
k 2 , j = f j t i + , yi , j + k 1, j
2 2
h h
k 3, j = f j t i + , y i , j + k 2 , j
2 2
(
k 4 , j = f j t i + h , y i , j + k 3, j h )
Algoritmul de rezolvare prin această metodă se poate concretiza astfel:
22
public class SistemRungeKutta {
/**
* @param args
*/
double getXmax(){
double xmax = 0;
for(int i=0; i<n; i++){
if(xmax < xArray[i]) xmax = xArray[i];
}
return xmax;
}
double getXmin(){
double xmin = 0;
for(int i=0; i<n; i++){
if(xmin > xArray[i]) xmin = xArray[i];
}
return xmin;
}
double getYmax(){
double ymax = 0;
for(int i=0; i<n; i++){
if(ymax < yArray[0][i]) ymax = yArray[0][i];
}
return ymax;
}
double getYmin(){
double ymin = 0;
for(int i=0; i<n; i++){
if(ymin > yArray[0][i]) ymin = yArray[0][i];
}
return ymin;
}
public SistemRungeKutta(){
int i;
23
double t = 0, tf = 0.05, h;
double[] y={0, -10};
double[] k1=new double[2];
double[] k2=new double[2];
double[] k3=new double[2];
double[] k4=new double[2];
h = (tf - t) / n;
for(i=0; i<n; i++){
t = i*h;
k1[0] = f1(t, y[0], y[1]);
k1[1] = f2(t, y[0], y[1]);
k2[0] = f1(t+h/2, y[0]+k1[0]*h/2, y[1]+k1[1]*h/2);
k2[1] = f2(t+h/2, y[0]+k1[0]*h/2, y[1]+k1[1]*h/2);
k3[0] = f1(t+h/2, y[0]+k2[0]*h/2, y[1]+k2[1]*h/2);
k3[1] = f2(t+h/2, y[0]+k2[0]*h/2, y[1]+k2[1]*h/2);
k4[0] = f1(t+h, y[0]+k3[0]*h, y[1]+k3[1]*h);
k4[1] = f2(t+h, y[0]+k3[0]*h, y[1]+k3[1]*h);
for(int j=0; j<2; j++){
y[j] += h/6 * (k1[j]+2*k2[j]+2*k3[j]+k4[j]);
yArray[j][i] = y[j];
}
xArray[i] = t+h;
}
System.out.println(Double.toString(SistemRungeKutta.xArray[i])
+"\t"+Double.toString(SistemRungeKutta.yArray[0][i])
+"\t"+Double.toString(SistemRungeKutta.yArray[1][i]));
}
import java.awt.*;
import javax.swing.*;
/**
* @param args
*/
private static final long serialVersionUID = 1235237784941049199L;
int Xmax = 800;
int Ymax = 600;
int XScale = 500;
int YScale = 250;
24
int xOffset = 150;
int yOffset = 300;
public GraficSistemRungeKutta(){
this.setSize(Xmax, Ymax);
}
25