problema traduzione da Visual Basic a Lazarus

[alexarmato66]

Quindi all'interno della funzione a cui passo l'array dinamico polic non serve che lo ridimensioni nuovamente  con setlength o devo farlo sempre?

[DragoRosso]

L'array dovrebbe venire ridimensionato in base all'uso che se ne fa.

Normalmente passare un array (o un suo sottoinsieme) a una funzione serve ad usare l'array (cioè riempirlo di dati, elaborali o leggerli), il ridimensianamento viene fatto solo se necessita.

Ciò che passi alla funzione è l'array stesso (o una struttura, una classe, etc ...) con le sue dimensioni originali. Il setlength non serve all'interno della funzione.

Ciao

P.S.: quando si passa qualcosa come riferimento lo si passa nella sua interezza, perchè si passa il riferimento. Ovviamente per interezza intendo il riferimento che si passa: se passo il riferimento di un membro di una classe mi ritrovo il membro nella funzione, non la classe.

[DragoRosso]

In genere non si dovrebbe aprire, a meno che tu non abbia settato qualche breakpoint in giro per il codice. Nel caso prova ad attivare la funzione "heapcrt" nelle opzioni di progetto (in allegato vedi dove).
All'uscita del programma viene generato un report con eventuali segnalazioni di LEAK di memoria.

ALTRI UTENTI DEL FORUM POTREBBERO ESSERTI DI AIUTO CON INFO MAGGIORI.

Ciao

[alexarmato66]

Ho provato a scrivere la seguente procedura che chiama un'altra procedura.La cosa strana che alla fine
dell'esecuzione della seconda procedura c'è un ritorno alla prima procedura senza un apparente motivo:



1a procedura:

Codice: [Seleziona]

 Procedure calcola_MomentiRottura( dom : Dominio_Rottura; soll : soll_esterne; MomentiRottura : momenti_rottura;flag_convergenza : Boolean; flag_circa : Boolean; index : Integer);
    var
     tipo_conv : integer;
  begin

   tipo_conv := StrtoInt(Form1.CBconverg.Text);

               case (tipo_conv) of

    1: begin        // Approssimato

       calcola_MomentiRottura_A(dom, soll, MomentiRottura, flag_convergenza, flag_circa, index) ;
          end;


    2: begin   // Bisezione
        calcola_MomentiRottura_B(dom, soll, MomentiRottura, flag_convergenza, flag_circa, index) ;
          end;


end;

  end;   

2a procedura

Codice: [Seleziona]

 Procedure calcola_MomentiRottura_A(dom : Dominio_Rottura; soll : soll_esterne; MomentiRottura : momenti_rottura;flag_convergenza : Boolean; flag_circa : Boolean; index : Integer);  ...........

la seconda procedura esegue correttamente il calcolo ma poi ritornando alla prima procedura i valori si azzerano.

[DragoRosso]

Posta una parte di codice un pò più consistente, così non si capisce cosa viene fatto.

1) Definizioni delle procedure usate;

2) Codice chiamante (non solo una riga) e codice chiamato.

Ciao

[alexarmato66]

Le strutture sono:

Codice: [Seleziona]

 dominio_rottura = record
   nd : Double;                       // Sforzo normale con cui si determinano i vari momenti di rottura
   mrx:array of Double ;       // vettore con i valori dei momenti Mrx del dominio
   mry:array of Double ;       // vettore con i valori dei momenti Mry del dominio
   ang:array of Double ;       // vettore con i valori dell//inclinazione sull//orizzontale dell//asse neutro in radianti, rotazione antioraria positiva
   nrc:array of Double ;       // vettore con valori dello sfozo normale nella parte compressa della sezione a rottura
   nrt:array of Double ;       // vettore con valori dello sforzo normale nella parte in trazione della sezione a rottura
   xrc:array of Double ;       // posizione della risultante dello sforzo di compressione
   yrc:array of Double ;       // (nel sistema di riferimento cartesiano della sezione)
   xrt:array of Double ;       // posizione della risultante dello sforzo di trazione
   yrt:array of Double ;       // (nel sistema di riferimento cartesiano della sezione)
   epsc:array of Double ;      // vettore con le deformazioni limite della fibra più compressa
   epss:array of Double ;      // vettore con le deformazioni limite della barra di armatura più distante dall//asse neutro
   yn:array of Double ;        // posizione asse neutro (nel sistema ruotato di ogni singola verifica)
   curv:array of Double ;      // Curvatura della deformazione della sezione
   End ;                                                                                          

Codice: [Seleziona]

oll_esterne =record
   N : Double ;                         // Sforzo normale: positovo se di compressione
   Mx : Double ;                        // Momento flettente asse momento X: positivo se comprime fibra Y+
   My : Double ;                        // Momento flettente asse momento Y: positivo se comprime fibra X+
   End;                                                                                     

Codice: [Seleziona]

momenti_rottura = record
    mrx : Double;                        // Momento di rottura con asse momento x
    mry : Double;                        // Momento di rottura con asse momento y
    ang : Double;                        // Rotazione dell//asse neutro rispetto all//asse x, antioraria positiva
    polix : Array of poligono_sezione;   // Poligono che definisce la porzione di cls compressa della sezione
    sigma_so: Array of Double;               // ' Array contenente le tensioni nelle barre di armatura a rottura
    sigma_sp: Array of Double;              // ' Array contenente le tensioni nei trefoli a rottura
    def_rottura : deform_sezione;        // configutrazione deformativa a rottura
    etac_max : Double;                   // distanza tra l//asse neutro e la fibra maggiormente compressa a rottura
    etas_min : Double;                   // distanza tra l//asse neutro e la fibra maggiormente tesa a rottura
    curv_rottura : Double;               // curvatura della sezione a rottura
    End ;                                                                      

La chiamante :

Codice: [Seleziona]

Procedure calcola_MomentiRottura( dom : Dominio_Rottura; soll : soll_esterne; MomentiRottura : momenti_rottura;flag_convergenza : Boolean; flag_circa : Boolean; index : Integer);
    var
     tipo_conv : integer;
  begin

   tipo_conv := StrtoInt(Form1.CBconverg.Text);

               case (tipo_conv) of

    1: begin        // Approssimato

       calcola_MomentiRottura_A(dom, soll, MomentiRottura, flag_convergenza, flag_circa, index) ;
          end;


    2: begin   // Bisezione
        calcola_MomentiRottura_B(dom, soll, MomentiRottura, flag_convergenza, flag_circa, index) ;
          end;

     { 3: begin // Secante
       calcola_MomentiRottura_C(dom, soll_SLU, MomentiRottura, flag_convergenza, flag_circa, index) ;
          end;
            }//questa devo ancora implementarla


end;

  end;  

La chiamata :

Codice: [Seleziona]

Procedure calcola_MomentiRottura_A(dom : Dominio_Rottura; soll : soll_esterne; MomentiRottura : momenti_rottura;flag_convergenza : Boolean; flag_circa : Boolean; index : Integer);

{
'flag_convergenza --> se TRUE convergenza della funzione e restituzione risultati precisi, se FALSE la funzione non è andata a convergenza
'flag_circa --> se TRUE vuol dire che la funzione non è andata a convergenza ma restituisce comunque un risultato conservativo
'se il flag_convergenza = FALSE ed il flag_circa = FALSE significa che non vengono restituiti valori accettabili, la funzione è fallita completamente
'index --> indice del primo punto del segmento del dominio in cui vi è la intersezione con la retta passante per [O.x, O.y] ed [soll.Mx soll.My]
'utile nel caso di fallimento della convergenza per infittire eventualmente i punti del dominio localmente e ritentare il calcolo }
 var

 i : Integer ;                //   'contatore generico
 ip1 : Integer ;                //                  'i+1
 k : Integer;                //                     'contatore generico
 kp1 : Integer;                //                   'k+1
 O : TipoPunto ;                //                  'punto origine della retta di sollecitazione
 Mx_My : TipoPunto ;                //              'punto che definise la retta di sollecitazione
 D_R_1 : TipoPunto;                //               'punto iniziale del generico segmento del dominio
 D_R_2 : TipoPunto ;                //              'punto finale del generico segmento del dominio
 retta_soll : TipoSegmento;                //       'retta di sollecitazione
 seg_dom : TipoSegmento;                //          'generico segmento del dominio
 P_int : TipoPunto ;                //              'punto di intersezione tra retta di sollecitazione e dominio di rottura
 P_int0 : TipoPunto ;                //             'punto di intersezione tra retta di sollecitazione e dominio di rottura
 np : Integer ;                //                   'contatore poligoni
 polic: array of poligono_sezione;            //'poligono copia che viene ruotato e sottoposto ad elaborazione
//polic:array[0..3] of poligono_sezione ;
 armco : armo_sezione ;                //           'armature copia che vengono ruotate e sottoposte ad elaborazione
 armcp : armp_sezione ;                //           'armature copia che vengono ruotate e sottoposte ad elaborazione
 Nfin : risultante_n_finale ;                //     'risultante degli sforzi ad asse neutro individuato
 ymax : Double ;                //                  'ordinata massima dei vertici della sezione
 yamin : Double ;                //                 'ordinata minima delle armature
 deformazione : Double ;
 x_provv : Double ;                //               'ascissa provvisoria
 y_provv : Double ;                //               'ordinata provvisoria
 r0 : Double  ;
 alfa : Double  ;
 Mrx_alfa : Double ;
 Mry_alfa : Double  ;
 r_alfa : Double  ;
 alfa1 : Double   ;
 Mrx_alfa1 : Double  ;
 Mry_alfa1 : Double  ;
 r_alfa1 : Double  ;
 alfa2 : Double   ;
 Mrx_alfa2 : Double   ;
 Mry_alfa2 : Double  ;
 r_alfa2 : Double  ;
 c : Double;                //  'variabile temporanea
 s : Double;                //  'variabile temporanea
 D : Double  ;
 DeltaP_dom : Double  ;



                 D0 : Double ;
                 d1 : Double;
                 d2 : Double ;

 label
 continua;

 begin


    SetLength(polic, N_POLI+1); //ReDim polic(N_POLI)
       SetLength(MomentiRottura.polix, N_POLI+1);     //ReDim MomentiRottura.polix(N_POLI)
         SetLength(MomentiRottura.sigma_so, arm.numarm+1);   //ReDim MomentiRottura.sigma_so(arm.numarm)
            SetLength(MomentiRottura.sigma_sp, armp.numarm+1);   // ReDim MomentiRottura.sigma_sp(armp.numarm)


// imposto di default false (convergenza fallita)
flag_convergenza := False;
// imposto di default false (risultato corretto)
flag_circa := False;

// 'If Abs(soll.My) > Abs(soll.Mx) Then
//'    r0 = soll.Mx / soll.My
//'Else
//'    r0 = soll.My / soll.Mx
//'End If

//'If Not soll.Mx = 0# Then
//'    r0 = soll.My / soll.Mx
//'Else
//'    r0 = Sgn(soll.My) * 100000000#
//'End If

//controllo se O è interno al dominio, se sì esiste un unico punto di intersezione col dominio



If Punto_Interno_poligonoB(0, 0, dom.mrx, dom.mry, NMaxDom) = 4 Then
    begin
    O.X := 0 ;
    O.Y := 0;
    Mx_My.X := soll.Mx ;
    Mx_My.Y := soll.My ;
    retta_soll.start := O  ;
    retta_soll.ends := Mx_My ;

    For i := 1 To NMaxDom   do
      begin
        If i = NMaxDom Then
        begin
        ip1 := 1 ;
         end
    Else
         begin
        ip1 := i + 1 ;
         end;


        D_R_1.X := dom.mrx[i];
        D_R_1.Y := dom.mry[i];
        D_R_2.X := dom.mrx[ip1];
        D_R_2.Y := dom.mry[ip1];
        seg_dom.start := D_R_1 ;
        seg_dom.ends := D_R_2 ;

        If IntersezRettaSegmento(retta_soll, seg_dom, P_int) = True Then
        begin
            If (sign(P_int.x) = sign(soll.Mx)) And (sign(P_int.y) = sign(soll.My)) Then
                begin
               // 'alfa1 = dom.ang(i): alfa2 = dom.ang(ip1)
               // 'alfa = (alfa1 + alfa2) / 2
                index := i; //'indice del punto corrente del dominio
                GoTo continua ;
            end ;
        end;
     end;
end



Else
     begin

   // 'se il punto sollecitante è fuori dal dominio non è verificato
 If Punto_Interno_poligonoB(soll.Mx, soll.My, dom.mrx, dom.mry, NMaxDom) = 1 Then Exit;

    O.X := 0;
    O.Y := 0;
    Mx_My.X := soll.Mx ;
    Mx_My.Y := soll.My ;
    retta_soll.start := O  ;
    retta_soll.ends := Mx_My  ;


  For i:= 1 To NMaxDom   do
      begin

      If i = NMaxDom Then
        begin
        ip1 := 1 ;
        end
      Else
        begin
        ip1 := i + 1 ;
        end;


        D_R_1.X := dom.mrx[i] ;
        D_R_1.Y := dom.mry[i] ;
        D_R_2.X := dom.mrx[ip1] ;
        D_R_2.Y := dom.mry[ip1] ;
        seg_dom.start := D_R_1 ;
        seg_dom.ends := D_R_2 ;


        If IntersezRettaSegmento(retta_soll, seg_dom, P_int) = True Then
            begin
            If (sign(P_int.X) = sign(soll.Mx)) And (sign(P_int.Y) = sign(soll.My)) Then
                begin
                //'alfa1 = dom.ang(i): alfa2 = dom.ang(ip1)
               // 'alfa = (alfa1 + alfa2) / 2
                index := i; //'indice del punto corrente del dominio

                //'verifico se esiste anche un altro punto di intersezione col dominio
               // 'dallo stesso lato.
               // '(questo succede nel caso di domini scostati dall'origine degli assi,
              //  'capita quando ci si aprossima a +Nmax o -Nmax, oppure anche nel
              //  'caso di alcuni profili particolari)

                D0 := (sqr(soll.Mx) + sqr(soll.My)) ;
                d2 := (sqr(P_int.X) + sqr(P_int.Y)) ;

                For k := i To NMaxDom  do
                      begin

                    If k = NMaxDom Then
                        begin
                        kp1 := 1;
                        end
                    Else
                        begin
                        kp1 := k + 1 ;
                         end;

                    D_R_1.X := dom.mrx[k] ;
                    D_R_1.Y := dom.mry[k] ;
                    D_R_2.X := dom.mrx[kp1] ;
                    D_R_2.Y := dom.mry[kp1];
                    seg_dom.start := D_R_1 ;
                    seg_dom.ends := D_R_2 ;

                    If IntersezRettaSegmento(retta_soll, seg_dom, P_int0) = True Then
                        begin
                        If (sign(P_int0.X) = sign(soll.Mx)) And (sign(P_int0.Y) = sign(soll.My)) Then
                            begin
                            d1 := (sqr(P_int0.X) + sqr(P_int0.Y))  ;
                            //'memorizzo il punto più distante da O
                            If d1 > d2 Then
                                begin
                                P_int := P_int0 ;
                                //'alfa1 = dom.ang(k): alfa2 = dom.ang(kp1)
                                //'alfa = (alfa1 + alfa2) / 2
                                index := k; //'indice del punto corrente del dominio
                                End ;
                           End ;
                        End ;

                      end;

                GoTo continua ;
            End ;
        End ;
    end;  // fine for i:=1 to.....

    end;





//'non ci sono intersezioni valide col poligono del dominio
Exit;

continua:
//'indica soluzione aprossimata
flag_circa := True;

//'convergenza secca sempre possibile
flag_convergenza := True;

//'calcoliamo col metodo secco di GIARIA recupernando index
i := index ;
If i = NMaxDom Then
    begin
    ip1 := 1;
    end
Else
    begin
    ip1 := i + 1;
    end;

D_R_1.X := dom.mrx[i] ;
D_R_1.Y := dom.mry[i] ;
D_R_2.X := dom.mrx[ip1] ;
D_R_2.Y := dom.mry[ip1];
alfa1 := dom.ang[i];
alfa2 := dom.ang[ip1];


If alfa2 < alfa1 Then
    begin
    alfa2 := alfa2 + 2 * pi;
     end;

D := sqrt(sqr(P_int.x - D_R_1.x) + sqr(P_int.y - D_R_1.y)) ;
DeltaP_dom := sqrt(sqr(D_R_2.x - D_R_1.x)+ sqr(D_R_2.y - D_R_1.y));
alfa := alfa1 + (alfa2 - alfa1) * D / DeltaP_dom  ;

//'calcola momenti resistenti con alfa
Mr_alfa (dom, soll, alfa, polic , armco, armcp, Nfin, ymax, yamin, mrx_alfa, mry_alfa, r_alfa );

If alfa > (2 * pi) Then
    begin
    alfa := (alfa - 2)* pi;
    end;

MomentiRottura.ang := alfa;
MomentiRottura.mrx := Mrx_alfa;
MomentiRottura.mry := Mry_alfa ;
MomentiRottura.def_rottura.epsa := Nfin.epsc ;
MomentiRottura.def_rottura.epsb := Nfin.epss ;
MomentiRottura.curv_rottura := Nfin.epsc / (ymax - Nfin.yn)  ;
MomentiRottura.etac_max := ymax - Nfin.yn  ;
MomentiRottura.etas_min := yamin - Nfin.yn ;





// Calcola una sola volta cos(alfa) e sin(alfa) per evitare elaborazione ogni volta
c := Cos(alfa) ;
s := Sin(alfa) ;
//vengono calcolate le tensioni nelle barre di armatura a rottura


      // setlength( armco.y,arm.numarm+1);
    //   setlength( arm.fyd,arm.numarm+1);

For i := 1 To arm.numarm  do
begin
    deformazione := Nfin.epsc * (armco.y[i] - Nfin.yn) / (ymax - Nfin.yn) ;
    MomentiRottura.sigma_so[i] := elast_plast_indef(deformazione, arm.fyd[i], E_arm);
end;
For i := 1 To armp.numarm    do
   begin
    deformazione := Nfin.epsc * (armcp.y[i] - Nfin.yn) / (ymax - Nfin.yn);
    MomentiRottura.sigma_sp[i] := elast_plast_indefps(deformazione + armp.def_prec[i], armp.fyd[i], E_armp);
   end;

//'viene individuato il poligono che delimita la porzione compressa
//'Calcola una sola volta Cos(alfa) e Sin(alfa) per evitare elaborazione ogni volta
c := Cos(alfa) ;
s := Sin(alfa) ;



//'viene individuato il poligono che delimita la porzione compressa
For np := 1 To N_POLI   do
   begin

    MomentiRottura.polix[np].numv := 0   ;

    For i := 1 To polic[np].numv do
       begin
        If i = polic[np].numv Then
            begin
            ip1 := 1 ;
            end
        Else
             begin
            ip1 := i + 1;
             end;
        If (polic[np].y[i] >= Nfin.yn) Then
            begin
            MomentiRottura.polix[np].numv := MomentiRottura.polix[np].numv + 1 ;

           // ReDim Preserve MomentiRottura.polix(np).X(1 To MomentiRottura.polix(np).numv)
           SetLength(MomentiRottura.polix[np].x, MomentiRottura.polix[np].numv+1);
           // ReDim Preserve MomentiRottura.polix(np).Y(1 To MomentiRottura.polix(np).numv)
            SetLength(MomentiRottura.polix[np].y, MomentiRottura.polix[np].numv+1);
            //ReDim Preserve MomentiRottura.polix(np).sigma(1 To MomentiRottura.polix(np).numv)
             SetLength(MomentiRottura.polix[np].sigma, MomentiRottura.polix[np].numv+1);


            MomentiRottura.polix[np].x[MomentiRottura.polix[np].numv] := poli[np].x[i]  ;
            MomentiRottura.polix[np].y[MomentiRottura.polix[np].numv] := poli[np].y[i] ;
            deformazione := Nfin.epsc * (polic[np].y[i] - Nfin.yn) / (ymax - Nfin.yn) ;
            MomentiRottura.polix[np].sigma[MomentiRottura.polix[np].numv] := parabola_rett(deformazione, polic[np].epsc0, polic[np].fd) ;
            end;

        If (sign(polic[np].y[i] - Nfin.yn)) <> (sign(polic[np].y[ip1] - Nfin.yn)) Then
            begin
            MomentiRottura.polix[NP].numv := MomentiRottura.polix[np].numv + 1;
            //'vengono prima individuate le coordinate del poligono ruotato
            x_provv := polic[np].x[i] + (polic[np].x[ip1] - polic[np].x[i]) * (Nfin.yn - polic[np].y[i]) / (polic[np].y[ip1] - polic[np].y[i]) ;
            y_provv := Nfin.yn;
            //'le coordinate appena trovate vengono quindi ruotate e riportate rispetto al sistema di riferimento originario

            //ReDim Preserve MomentiRottura.polix(NP).X(1 To MomentiRottura.polix(NP).numv)
            //ReDim Preserve MomentiRottura.polix(NP).Y(1 To MomentiRottura.polix(NP).numv)
            //ReDim Preserve MomentiRottura.polix(NP).sigma(1 To MomentiRottura.polix(NP).numv)

           SetLength(MomentiRottura.polix[np].x, MomentiRottura.polix[np].numv+1);
            SetLength(MomentiRottura.polix[np].y, MomentiRottura.polix[np].numv+1);
             SetLength(MomentiRottura.polix[np].sigma, MomentiRottura.polix[np].numv+1);

            MomentiRottura.polix[np].x[MomentiRottura.polix[np].numv] := x_provv * c - y_provv * s ;
            MomentiRottura.polix[np].y[MomentiRottura.polix[np].numv] := x_provv * s + y_provv * c  ;
           End;
   end; //Next i
end;//Next NP









end;    

[alexarmato66]

HO fatto delle prove e sucede che quando la procedura 'Procedure calcola_MomentiRottura_A'  termina il calcolo i valori passati si annullano all'uscita dalla procedura stessa.

[alexarmato66]

 :)RISOLTO!!!
Dovevo semplicemente passare certi valori come riferimento!!:

Codice: [Seleziona]

 Procedure calcola_MomentiRottura_A( dom : Dominio_Rottura; soll : soll_esterne;var MomentiRottura : momenti_rottura;flag_convergenza : Boolean; flag_circa : Boolean; index : Integer);