* * * *

Privacy Policy

Blog italiano

Clicca qui se vuoi andare al blog italiano su Lazarus e il pascal.

Forum ufficiale

Se non siete riusciti a reperire l'informazione che cercavate nei nostri articoli o sul nostro forum vi consiglio di visitare il
Forum ufficiale di Lazarus in lingua inglese.

Lazarus 1.0

Trascinare un file nel programma
DB concetti fondamentali e ZeosLib
Recuperare codice HTML da pagina web
Mandare mail con Lazarus
Stabilire il sistema operativo
Esempio lista in pascal
File INI
Codice di attivazione
Realizzare programmi multilingua
Lavorare con le directory
Utilizzare Unità esterne
TTreeView
TTreeview e Menu
Generare controlli RUN-TIME
LazReport, PDF ed immagini
Intercettare tasti premuti
Ampliare Lazarus
Lazarus e la crittografia
System Tray con Lazarus
UIB: Unified Interbase
Il file: questo sconosciuto
Conferma di chiusura di un applicazione
Liste e puntatori
Overload di funzioni
Funzioni a parametri variabili
Proprietà
Conversione numerica
TImage su Form e Panel
Indy gestiore server FTP lato Client
PopUpMenu sotto Pulsante (TSpeedButton)
Direttiva $macro
Toolbar
Evidenziare voci TreeView
Visualizzare un file Html esterno
StatusBar - aggirare l'errore variabile duplicata
Da DataSource a Excel
Le permutazioni
Brute force
Indy 10 - Invio email con allegati
La gestione degli errori in Lazarus
Pascal Script
Linux + Zeos + Firebird
Dataset virtuale
Overload di operatori
Lavorare con file in formato JSON con Lazarus
Zeos ... dietro le quinte (prima parte)
Disporre le finestre in un blocco unico (come Delphi)
Aspetto retrò (Cmd Line)
Lazarus 1.0
Come interfacciare periferica twain
Ubuntu - aggiornare free pascal e lazarus
fpcup: installazioni parallele di lazarus e fpc
Free Pascal e Lazarus sul Raspberry Pi
Cifratura: breve guida all'uso dell'algoritmo BlowFish con lazarus e free pascal.
Creare un server multithread
guida all'installazione di fpc trunk da subversion in linux gentoo
Indice
DB concetti fondamentali e connessioni standard
Advanced Record Syntax
DB concetti fondamentali e DBGrid
DB concetti fondamentali e TDBEdit, TDBMemo e TDBText
Advanced Record Syntax: un esempio pratico
Superclasse form base per programmi gestionali (e non)
Superclasse form base per programmi gestionali (e non) #2 - log, exception call stack, application toolbox
Superclasse form base per programmi gestionali (e non) #3 - traduzione delle form
Superclasse form base per programmi gestionali (e non) #4 - wait animation
Un dialog per la connessione al database:TfmSimpleDbConnectionDialog
Installare lazarus su mac osx sierra
immagine docker per lavorare con lazarus e free pascal
TDD o Test-Driven Development
Benvenuto! Effettua l'accesso oppure registrati.
Gennaio 17, 2022, 08:24:02 am

Inserisci il nome utente, la password e la durata della sessione.

16 Visitatori, 0 Utenti

Autore Topic: problema traduzione da Visual Basic a Lazarus  (Letto 1910 volte)

alexarmato66

  • Jr. Member
  • **
  • Post: 70
  • Karma: +0/-0
Re:problema traduzione da Visual Basic a Lazarus
« Risposta #45 il: Maggio 25, 2021, 01:10:56 pm »
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

  • Scrittore
  • Sr. Member
  • *****
  • Post: 445
  • Karma: +7/-0
  • Prima ascoltare, poi decidere
Re:problema traduzione da Visual Basic a Lazarus
« Risposta #46 il: Maggio 25, 2021, 02:25:55 pm »
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.
« Ultima modifica: Maggio 25, 2021, 02:29:35 pm da DragoRosso »
:) Ogni alba è un regalo, ogni tramonto è una conquista :)

DragoRosso

  • Scrittore
  • Sr. Member
  • *****
  • Post: 445
  • Karma: +7/-0
  • Prima ascoltare, poi decidere
Re:problema traduzione da Visual Basic a Lazarus
« Risposta #47 il: Maggio 28, 2021, 05:22:05 pm »
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
:) Ogni alba è un regalo, ogni tramonto è una conquista :)

alexarmato66

  • Jr. Member
  • **
  • Post: 70
  • Karma: +0/-0
Re:problema traduzione da Visual Basic a Lazarus
« Risposta #48 il: Maggio 29, 2021, 11:17:05 am »
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

  • Scrittore
  • Sr. Member
  • *****
  • Post: 445
  • Karma: +7/-0
  • Prima ascoltare, poi decidere
Re:problema traduzione da Visual Basic a Lazarus
« Risposta #49 il: Maggio 29, 2021, 02:10:33 pm »
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
:) Ogni alba è un regalo, ogni tramonto è una conquista :)

alexarmato66

  • Jr. Member
  • **
  • Post: 70
  • Karma: +0/-0
Re:problema traduzione da Visual Basic a Lazarus
« Risposta #50 il: Maggio 29, 2021, 02:31:54 pm »
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

  • Jr. Member
  • **
  • Post: 70
  • Karma: +0/-0
Re:problema traduzione da Visual Basic a Lazarus
« Risposta #51 il: Maggio 30, 2021, 07:32:30 am »
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

  • Jr. Member
  • **
  • Post: 70
  • Karma: +0/-0
Re:problema traduzione da Visual Basic a Lazarus
« Risposta #52 il: Maggio 30, 2021, 07:36:45 am »
 :)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); 

 

Recenti

How To

Utenti
Stats
  • Post in totale: 15842
  • Topic in totale: 1946
  • Online Today: 29
  • Online Ever: 900
  • (Gennaio 21, 2020, 08:17:49 pm)
Utenti Online
Users: 0
Guests: 16
Total: 16

Disclaimer:

Questo blog non rappresenta una testata giornalistica poiché viene aggiornato senza alcuna periodicità. Non può pertanto considerarsi un prodotto editoriale ai sensi della legge n. 62/2001.