Risoluzione equazioni non lineari

Per valutare si considera l’equazione della retta AB, A e B :

e si pone in essa e , si ottiene così .

Per ottenere un’ulteriore approssimazione, si ripete nell’intervallo , la procedura

ora illustrata per ottenere .

La corda A’B interseca l’asse nel punto Q .

Per valutare si considera l’equazione della retta A’B, A’ e B e in

essa si pone e , ottenendo: .

Si ripete questo procedimento negli intervalli , , … , fino ad ottenere la

precisione voluta.

Il procedimento illustrato fornisce sempre valutazioni approssimate per difetto di .

Il metodo delle corde, inoltre, per le considerazioni già esposte, si presta bene al

calcolo della , , …, .

METODO DI NEWTON-RAPHSON

Il metodo di Newton-Rapson è la tecnica più usata per la risoluzione di sistemi non

lineari. Operando secondo tale metodo si suddividono le azioni esterne in incrementi di

i-

carico . Come mostrato nel metodo precedente, l’equazione di equilibrio nell’

esimo incremento di carico ha la forma seguente:

essendo la matrice di rigidezza tangente corrispondente alla configurazione

deformata determinata alla fine del passo precedente i-

Risolta tale equazione si determina una prima stima degli spostamenti alla fine dell’

esimo passo:

A partire dagli spostamenti possono essere determinate le forze sui vari elementi

strutturali e quindi, tramite semplici condizioni di equilibrio, le forze nodali

corrispondenti alla configurazione deformata ottenuta. Tali forze sono in generale

differenti da quelle applicate, e può quindi essere determinato un vettore degli

squilibri nodali:

Si applica quindi al sistema deformato nella configurazione il vettore degli squilibri

nodali e si risolve la nuova equazione:

nella quale è la matrice di rigidezza tangente calcolata per gli spostamenti . Il

dell’i-esimo

nuovo vettore spostamenti alla fine passo è:

La procedura viene ripetuta iterativamente fino alla convergenza della soluzione

all’interno del passo, e quindi si passa all’incremento di carico successivo. Per un

semplice sistema strutturale ad un solo grado di libertà la procedura descritta è

rappresentata dal diagramma in figura.

Il metodo di Newton-Rapson converge molto rapidamente alla soluzione, ma richiede

l’assemblaggio e l’inversione della matrice di rigidezza tangente più volte all’interno

dello stesso incremento di carico.

PARTE PRATICA: Nella parte pratica dell’esperienza si procede con la

realizzazione vera e propria del software, si analizzano i metodi sopra descritti

teoricamente e si cerca di tradurre i procedimenti matematici nel linguaggio di

programmazione. Come per la teoria la pratica verrà suddivisa in due parti,

riguardanti rispettivamente i due metodi.

Come primo metodo possiamo analizzare quello delle secanti detto anche

metodo delle corde, analizziamo alcuni frammenti di codice inseriti all’interno

del software:

Con la funzione Polinom(x) andiamo a calcolare il valore del polinomio:

Function polinom(x)

polinom = 0

For i = 0 To 10

polinom = polinom + Val(Text1(10 - i).Text) * x ^ i

Next i

End Function

La funzione trasc(x) ci permette di calcolare il valore della funzione

trascendente:

Function trasc(x)

trasc = b7 * Sin(x) + b6 * Cos(x) + b5 * Exp(x) + b4 * x * Exp(x) + b3 * Sqr(1 + x ^ 2) +

b2 * Atn(x) + b1 * x * Sin(x) + b0 * x * Cos(x)

End Function

Per calcolare invece il valore dell’intera funzione f(x) usiamo la

funzione f(x):

Function f(x)

f = polinom(x) + trasc(x)

End Function

Dopo aver scritto le funzioni necessarie si procederà con la dichiarazione delle variabili

(che non presento in quanto non necessita di particolare attenzione, per il suo basso

grado di difficoltà), comunque consiste nell’assegnare a delle variabili scelte

dall’utente i valori corrispondenti ai valori inseriti nelle TextBox della form principale

mentre il software è in esecuzione. Variabili che useremo poi nell’implementazione del

codice che, possiamo dire, è il fulcro del software, cioè l’insieme di istruzioni che c

permettono di calcolare il valore approssimato della funzione tramite il metodo delle

corde.

Il codice è il seguente:

If f(A) * f(B) > 0 Then

MsgBox ("Errore")

Else

If f(A) * f(B) = 0 Then

If f(A) = 0 Then

MsgBox ("f(A) è uguale a 0")

End If

If f(B) = 0 Then

MsgBox ("f(B) è uguale a 0")

End If

Else

If f((A + B) / 2) > ((f(A) + f(B)) / 2) Then

sds = -1

Else

If f((A + B) / 2) < ((f(A) + f(B)) / 2) Then

sds = 1

Else

MsgBox ("impossibile")

End If

End If

If f(A) * sds < 0 Then

Do

C = A - (B - A) / (fb - fa) * fa

fa = f(C)

Err = Abs(A - C)

A = C

Loop Until Err < 0.0001

MsgBox (Str(A))

Else

Do

C = B - (A - B) / (fa - fb) * fb

fb = f(C)

Err = Abs(B - C)

B = C

Loop Until Err < 0.0001

MsgBox (Str(B))

End If

End If

End If

End Sub

Per cominciare si verificano i valori delle funzioni f(a) ed f(b), e se risultano uguali al

valore 0 allora questo evento viene segnalato tramite una MessageBox.

Per verificare da dove ottenere il valore approssimato della funzione, cioè se partire

f(A) *

dall’estremo a o dall’estremo b si effettua una verifica sul risultato del prodotto

sds se è minore di 0 si prende in considerazione l’estremo a altrimenti si parte

dall’estremo b.

Infine ne risulterà la seguente formula : C = A - (B - A) / (fb - fa) * fa, altrimenti nel

caso contrario le variabili A e B vengono praticamente invertite e lo stesso con f(a) e

f(b) ossia: C = B - (A - B) / (fa - fb) * fb.

Nell’implementazione del codice riguardante il metodo di newton si procede

analogamente al metodo delle corde.

Qui sotto vengono riportati i due cicli che permettono di verificare gli estremi di

partenza per il calcolo approssimato dell’integrale. f(a)* dsf se quest’ultimo è

Con queste righe di codice verifichiamo il prodotto

maggiore di 0 allora si partirà dall’estremo a:

If f(a)* dsf>0 [viene verificato

then x0=a

do x1= x0 – (f(x0))/df(x0)

err = abs(x1-x0)

x0 = x1

loop until err < 0.00001

text 1. text= val(x1) f(a)* dsf sia minore di 0 allora

In questo secondo caso verifichiamo che il prodotto

procediamo con il calcolo partendo dall’estremo b:

else x0=b

do x1=x0– (f(x0))/df(x0)

err= abs(x1-x0)

x0=x1

loop until err< 0,00001

end if