Italian community of Lazarus and Free Pascal

Quando si lavora con variabili di tipo numerico serve poter effettuare diverse operazioni, dalle più semplici alle più complesse. Molte di queste operazioni sono già previste dal linguaggio stesso. Iniziamo con le 4 operazioni più semplici.

SOMMARE: per poter sommare due o più valori si usa come logica imporrebbe il simbolo +, vediamo un esempio: Variabile1:=Variabile1+1 . Con questo ultimo esempio abbiamo permesso alla variabile di auto incrementarsi di uno, un operazione all'ordine del giorno nel mondo della programmazione.

SOTTRARRE: per sottrarre dei valori si usa come logica imporrebbe il simbolo -, vediamo un esempio: Variabile1:=Variabile1+1 . Con questo esempio abbiamo permesso alla variabile di auto decrementarsi di uno.

MOLTIPLICARE: per moltiplicare uno o più valori si utilizza il simbolo *. Vediamo ora l'esempio: Variabile1:=Variabile1*2 . Con questo codice abbiamo permesso alla variabile di raddoppiare il suo valore.

DIVIDERE: per dividere uno o più valori utilizziamo il simbolo /. L'esempio risulta scritto così: Variabile1:=Variabile1/2 . Con questo ultimo esempio abbiamo permesso alla variabile di dividere il suo valore in due.

Abbiamo visto le quattro operazioni matematiche più diffuse, ora vediamo quelle un po' meno all'ordine del giorno.

RADICE QUADRATA: per ottenere la radice quadrata di un valore x ci basta usare la funzione SQRT(x).

QUADRATO: per ottenere il quadrato di un valore x ci basta usare la funzione SQR(x).

VALORE ASSOLUTO: per ottenere il valore assoluto di un valore x ovvero il valore senza il segno ci viene in aiuto la funzione ABS(x).

ARROTONDAMENTO: per ottenere l'arrotondamento di un valore x utilizziamo la funzione ROUND(x).

TRONCAMENTO: per ottenere la parte numerica prima della virgola di un valore x utilizziamo la funzione Trunc(x) o la funzione INT(x).

PARTE DECIMALE: per ottenere la parte decimale di un valore x ci viene in soccorso la funzione Frac(x).

SENO: la funzione che restituisce il seno di un valore x è SEN(x).

COSENO: la funzione che restituisce il coseno di un valore x è COS(x).

ARCOTANGENTE: la funzione che restituisce l'arcotangente di un valore x è ARCTAN(x).

LOGARITMO NATURALE: la funzione che restituisce il logaritmo naturale di un valore x è LN(x).

ANTILOGARITMO NATURALE: la funzione che restituisce l'antilogaritmo naturale di x è EXP(x).

PI GRECO: per ottenere il PIGRECO ci viene in aiuto la costante PI.

Le altre funzioni sono ricavate dalla combinazione delle precedenti, ad esempio l'elevamento a potenza x^y si ottiene combinando EXP e LN in questa maniera: EXP(LN(x)*y). Vediamo ora un esempio che conprende tutte le funzioni matematiche viste in questo capitolo.

Dichiariamo una variabile di nome Variabile1 e inseriamo il codice qua sotto riportato.

Variabile1:=4;

writeln('Valore iniziale: ',Variabile1);

Variabile1:=Variabile1+3;

writeln('Valore iniziale incrementato di 3: ',Variabile1);

Variabile1:=Variabile1-2;

writeln('Valore decrementato di 2: ',Variabile1);

Variabile1:=Variabile1*2;

writeln('Valore raddoppiato: ',Variabile1);

Variabile1:=Variabile1/3;

writeln('Valore diviso 3: ',Variabile1);

Variabile1:=Abs(-2);

writeln('Valore assoluto di -2: ',Variabile1);

Variabile1:=Sqr(4);

writeln('4^2: ',Variabile1);

Variabile1:=Sqrt(16);

writeln('Radice quadrata di 16: ',Variabile1);

Variabile1:=Round(1.5);

writeln('Arrotondamento di 1,5: ',Variabile1);

Variabile1:=Trunc(1.5);

writeln('Troncamento di 1,5: ',Variabile1);

Variabile1:=Int(1.5);

writeln('Intero 1,5: ',Variabile1);

Variabile1:=Frac(1.5);

writeln('Parte decimale 1,5: ',Variabile1);

writeln('Seno di 4: ', Sin(4));

writeln('Coseno di 4: ', Cos(4));

writeln('Arcotangente di 4: ', ArcTan(4));

writeln('Logaritmo naturale di 4: ', Ln(4));

writeln('Antilogaritmo naturale di 4: ', Exp(4));

writeln('PI greco: ', PI);

writeln('Elevamento a potenza: 4^3',Exp(LN(4)*3));

Compilate e vedrete il risultato del vostro lavoro.

A volte capita che si necessita di lavorare con liste, chi ha programmato in c o in c++ sa quanto queste liste possono tornare utili.
Bene in pascal è molto facile usare una lista e i puntatori.

Segue un listato di esempio, basta guardare i commenti per poter capire cosa succede.

unit ListaCaratteri; {nome della unit}

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils;

{ci salvo i caratteri}
Type Caratteri=^Cella; {Definisco un tipo di dato che si chiama caratteri ed è un puntatore ad un tipo cella}

     Cella=Record {definisco un nuovo tipo di dati che si chiama cella ed è un record ed è così composta:}
        Carattere:char; {contiene un carattere}
        Next:Caratteri {contiene un puntatore ad un altra variabile di tipo Caratteri, questo permette di puntare al nodo dopo della lista}
   End;

{ci salvo le liste di caratteri - è in tutto e per tutto uguale al tipo di dato Caratteri come logica}
Type ListeCar=^MiaCella;

     MiaCella=Record
        IdentificativoLista: string;
        Lista:Caratteri; {notare che come tipo di dato ho anche una lista, una lista all'interno di una lista si può fare}
        Next:ListeCar {puntatore al prossimo nodo}
   End;


type
        ListKeyPress = Object {creo un oggetto che contiene funzioni e procedure ma anche i miei dati di tipo lista}
        private
            MiaLista: ListeCar; {dati: contiene la mia lista}
            procedure Cancella(NodoPartenza: ListeCar); {funzione che mi cancella un nodo della lista}
            procedure CancellaCaratteri(NodoPartenza: Caratteri); {cancello la lista di tipo caratteri contenuta nella lista di tipo ListeCar}
        public
            constructor Create; {costruttore dell'oggetto}
            destructor Destroy; {distruttore dell'oggetto}
            procedure InsertChar(Car: char; Identificativo: string);
            procedure Show();
            procedure CancellaQuelloCheNonServe(LimiteMaxCar: integer);
            procedure CancellaNodiNonInLista(LenVettore: integer; var ListaValidi: array of string);
            function InVettore(LenVettore: integer; var ListaValidi: array of string; Identificativo: string): boolean;

    end;

implementation

constructor ListKeyPress.Create();
begin
     MiaLista:=nil; { inizializzo la mia lista padre con il nil=null del c, fondamentale per non far andare in errore il codice, perchè il null è sinonimo di fine lista }
end;

procedure ListKeyPress.InsertChar(Car: char; Identificativo: string);
var
   app, ultimo: ListeCar;
   ElencoCar: Caratteri;
   Esci: boolean;
begin
     app:=MiaLista;
     Esci:=FALSE;
     while ((app<>nil)and(Esci=FALSE)) do          {finche'non finisce la lista}
     begin
         If (App^.IdentificativoLista = Identificativo) Then
         begin
              New(ElencoCar);
              ElencoCar^.Carattere:=Car;
              ElencoCar^.Next:=app^.Lista;
              app^.Lista:=ElencoCar;
              Esci:=TRUE;
         end;
         ultimo:=app;
     app:=app^.next; {tramite questa instruzione si va avanti nella lista}
     end;
     If Esci=FALSE then { vuol dire che è il primo carattere per questo identificativo }
     begin
          app:=ultimo; //serve per gestire dal secondo nodo in poi altrimenti mi cera problemi

          New(ultimo); //simile alla malloc del c
          ultimo^.IdentificativoLista:=Identificativo; //valorizzo il campo del nodo della lista
          ultimo^.Lista:=nil;
          ultimo^.Next:=Nil; //valorizzo con nil perchè lo metto come ultimo carattere della lista
          if MiaLista=nil then
          begin
             app:=ultimo; //gestisco il primo nodo della lista
          end
          else
          begin
              app^.Next:=ultimo;
          end;

          New(ElencoCar);
          ElencoCar^.Carattere:=Car;
          ElencoCar^.Next:=ultimo^.Lista;
          ultimo^.Lista:=ElencoCar;
     end;
     if MiaLista=nil then
        MiaLista:=app;
end;

procedure ListKeyPress.Show();
var
   app: ListeCar;
   ElencoCar: Caratteri;
begin
     writeln('--- Inizio stampa ---');
     app:=MiaLista;
     while (app<>nil) do          {finche'non finisce la lista}
     begin
          writeln('Identificativo della lista: ', app^.IdentificativoLista);
          ElencoCar:=app^.Lista;
          while (ElencoCar<>nil) do          {finche'non finisce la lista}
          begin
               write(Elencocar^.Carattere);
               ElencoCar:=ElencoCar^.Next;
          end;
          writeln;
          app:=app^.next; {tramite questa instruzione si va avanti nella lista}
     end;
     writeln('--- Fine stampa ---');
end;

destructor ListKeyPress.Destroy();
begin
     Cancella(MiaLista);
     MiaLista:=nil;
end;

procedure ListKeyPress.Cancella(NodoPartenza: ListeCar);
var
   app: ListeCar;
begin
     app:=NodoPartenza;
     if (app<>nil) then          {finche'non finisce la lista}
     begin
          Cancella(app^.next); {tramite questa instruzione si va avanti nella lista}
          CancellaCaratteri(app^.Lista); {cancello i caratteri del nodo della lista}
          dispose(app); {cancello dalla memoria il nodo della lista, simile la free del c}
     end;
end;

procedure ListKeyPress.CancellaCaratteri(NodoPartenza: Caratteri);
var
   app: Caratteri;
begin
     app:=NodoPartenza;
     if (app<>nil) then          {finche'non finisce la lista}
     begin
          CancellaCaratteri(app^.next); {tramite questa instruzione si va avanti nella lista}
          dispose(app); {cancello dalla memoria il nodo della lista}
     end;
end;

procedure ListKeyPress.CancellaQuelloCheNonServe(LimiteMaxCar: integer);
var
   app: ListeCar;
   ElencoCar: Caratteri;
   Cont: integer;
   Esci: boolean;
begin
     app:=MiaLista;
     while (app<>nil) do         {finche'non finisce la lista}
     begin
          {devo scorrere tutte le variabili }
          Cont:=1;
          Esci:=FALSE;
          ElencoCar:=app^.Lista;
          while ((ElencoCar<>nil)and(Esci=FALSE)) do          {finche'non finisce la lista}
          begin
               If (Cont >= LimiteMaxCar) Then
               begin
                    CancellaCaratteri(ElencoCar^.Next);
                    ElencoCar^.Next:=nil;
                    Esci:=TRUE;
               End
               Else
               begin
                    ElencoCar:=ElencoCar^.Next;
                    Inc(Cont);
               end;
          end;
          app:=app^.next; {tramite questa instruzione si va avanti nella lista}
     end;
end;

procedure ListKeyPress.CancellaNodiNonInLista(LenVettore: integer; var ListaValidi: array of string);
Var
   app, app2, precedente: ListeCar;
   Flag: boolean;
begin
     app:=MiaLista;
     app2:=MiaLista;
     precedente:=nil;
     while (app<>nil) do         {finche'non finisce la lista}
     begin
          Flag:=FALSE;
          {devo scorrere tutte le variabili }
          If InVettore(LenVettore, ListaValidi, app^.IdentificativoLista) = False Then
          begin
               Flag:=TRUE;
               app2:=app^.Next;
               CancellaCaratteri(app^.Lista);
               dispose(app);
               app:=app2;
               if precedente=nil then
                  MiaLista:=app
               else
                   precedente^.Next:=app;
          end;
          if ((app<>nil)AND(Flag=FALSE)) then
          begin
               precedente:=app;
               app:=app^.next; {tramite questa instruzione si va avanti nella lista}
          end;
     end;
end;

function ListKeyPress.InVettore(LenVettore: integer; var ListaValidi: array of string; Identificativo: string): boolean;
Var
   ret: boolean;
   i: integer;
begin
     ret:=FALSE;
     i:=0;
     while ((i      begin
          //writeln('Confronto:',ListaValidi[i],'-',Identificativo);
          if (ListaValidi[i]=Identificativo) then
               ret:=TRUE;
          Inc(i);
     end;
   InVettore:=ret;
end;

end.

Potete trovare un esempio completo qui: www.lazaruspascal.it/esempi/Lista_Pascal.zip

Presentazione di MyErp:

Pagina di riferimento: http://www.myerpsistema.com/

MyErp - Software Gestionale (di seguito abbreviato MyErp) è un potente software, scritto con Lazarus Free Pascal, che consente di gestire i diversi aspetti gestionali (fatturazione, magazzino, amministrazione, contabilità, agenti, ecc.) di un'azienda italiana, introducendo tuttavia un innovativo know-how e nuove ed elevatissime possibilità di automazione in particolare per quanto riguarda l'area amministrativa e contabile, che sicuramente è il fiore all'occhiello di MyErp.

MyErp consente infatti di automatizzare il 70/80% della gestione amministrativa e contabile di un'azienda, con conseguente notevole risparmio di costi, a fronte di un miglioramento generalizzato della gestione, che risulta più efficiente per la riduzione dell'incidenza dell'errore umano.

Prima di tutto MyErp è stato pensato da chi si confronta tutti i giorni con le problematiche gestionali e che, oltre ad avere le competenze ragionieristiche, contabili e fiscali ha anche quelle informatiche, riuscendo pertanto a realizzare un nuovo sistema di gestione ed a sfruttare tutto quello che la tecnologia di oggi rende disponibile per velocizzare e rendere più efficiente l'amministrazione di un'azienda italiana.

Ad esempio, la disponibilità dei dati bancari in formato elettronico consente di automatizzare oltre l'80-90% delle registrazioni bancarie, mentre la realizzazione di interfacce semplificate ad inserimento rapido consente un veloce inserimento, anche da parte di persone senza una specifica preparazione ragionieristica, delle più ricorrenti operazioni aziendali che non possono essere del tutto automatizzate, ma che possono invece essere grandemente semplificate e velocizzate.

Inoltre, molti aspetti relativi alla tesoreria sul fronte attivo (preavvisi di pagamento ai clienti, controllo e monitoraggio dei crediti, sollecito insoluti via mail e/o fax, ecc.) possono essere agevolmente automatizzati, consentendo un'azione più tempestiva, efficiente ed incisiva sul fronte del recupero crediti, insieme ad una drastica diminuzione dei costi di gestione, così come l'invio automatico delle fatture in formato PDF via e-mail.

Analogamente una gestione più efficiente della tesoreria sul fronte passivo permette notevoli risparmi sui tempi di gestione, anche attraverso i nuovi strumenti messi a disposizione dalle banche, ad esempio importando dal Remote Banking i dati relativi ai pagamenti da effettuare, senza più dovere perdere tempo ad effettuare manualmente i bonifici uno alla volta.

Anche i controlli della gestione amministrativa e della primanota possono essere in gran parte automatizzati, consentendo una drastica riduzione dei tempi ed al tempo stesso un'efficiente e rigorosa gestione degli utenti attraverso un controllo degli inserimenti con un sistema gerarchico di tipo piramidale, volto a verificare ed individuare eventuali errori nell'inserimento dei dati.

Il software introduce inoltre un nuovo know-how di tipo ragionieristico, consentendo un puntuale ed immediato controllo della gestione, grazie all'innovativo sistema di gestione delle partite aperte, alla gestione dei conti transitori (risolvendo, tra l'altro, l'annoso problema della riconciliazione degli estratti conto bancari), al controllo del numero dei documenti che devono essere registrati annualmente (p.es. fatture di leasing, affitti, utenze).
 
Infine, una gestione più snella ed efficiente favorisce, soprattutto nelle aziende di minori dimensioni, un adeguato e proficuo interscambio dei dati tra azienda e studio di consulenza, evitando che lo studio si trovi ad elaborare i documenti aziendali "a blocchi" (spesso mensili), fornendo poi le elaborazioni all'azienda con tempi troppo lunghi ed incompatibili con le proprie necessità di gestione, costringendo pertanto l'azienda ad istituire un proprio sistema gestionale interno, del tutto parallelo a quello che poi verrà elaborato dallo studio, per potere tenere controllati i pagamenti e le riscossioni.

La gestione della fatturazione e del magazzino consente di gestire le fatture ad importo fisso per le aziende di servizi che fatturano importi costanti tutti i mesi, includono la gestione di più magazzini, dei listini, dei parametri aggiuntivi (colori, taglie, ecc.), dei lotti, degli ordini, della visualizzazione degli articoli sottoscorta, delle promozioni, della scontistica, degli agenti e delle provvigioni, oltre ad una serie di stampe ed elaborazioni completamente personalizzabili.

MyErp esiste in diverse versioni, dalla più semplice alla più completa. Entrambe condividono il database, differiscono tra loro solo per i moduli abilitati. Esiste inoltre una versione solo contabile, pensata per coloro che vogliono mantenere il proprio gestionale per gli altri aspetti, ma desiderano utilizzare MyErp per la gestione amministrativa e contabile. Tutte le versioni possono essere provate senza impegno prima dell'acquisto.

Per maggiori informazioni scrivere a: info@myerpsistema.com o consultare il sito http://www.myerpsistema.com/ .

Brochure in formato PDF:

http://www.myerpsistema.com/index.php?option=com_remository&Itemid=121&func=fileinfo&id=1

Presentazioni in formato PDF:

http://www.myerpsistema.com/index.php?option=com_remository&Itemid=121&func=fileinfo&id=2

http://www.studiocortelli.com/index.php?mod=28_Download&downloadfile=Articoli/Proposta_di_automazione_area_amministrativa_e_contabile.pdf&mode=go

Impressioni di Stefano Cortelli su Lazarus:

La mia esperienza con Lazarus inizia nel 2006, quando ho deciso di iniziare a fare il porting del precedente gestionale che avevo sviluppato in Delphi, con l'obiettivo di creare però un nuovo ed ambizioso progetto, che ho chiamato MyErp, affascinato dalle potenzialità di un linguaggio di programmazione che, fornendo un eccellente ambiente RAD del tutto simile a quello di Delphi, permettesse di compilare in nativo sui principali sistemi operativi.

In particolare, ero molto interessato al porting su Linux, per la SUA maggiore stabilità e sicurezza, senza tuttavia potermi permettere di rinunciare al funzionamento sotto Windows.

Ho trovato in Lazarus il miglior compromesso finora mai realizzato tra prestazioni e portabilità: certo non così veloce come il C, ma con portabilità sui principali sistemi operativi; certamente non così portabile come Java o Python, ma enormemente più veloce di questi. Per questo ho deciso di "scommettere" su un progetto, Lazarus, che allora era ancora in pieno sviluppo, ma che lasciava intravvedere le sue enormi potenzialità.

Ebbene, superate le difficoltà dei primi tempi, le aspettative non sono state disattese, Lazarus nel frattempo ha fatto passi da gigante, diventando un ambiente di sviluppo sempre più stabile e completo, e devo dire che proprio grazie a Lazarus ho potuto portare avanti un progetto di dimensioni consistenti, un software gestionale pensato in primis per aziende medie (oggi è utilizzato da aziende con oltre cento dipendenti).

La comunità di Lazarus è inoltre molto attiva, e questo costituisce sicuramente un ulteriore punto a favore, problemi e domande trovano normalmente risposta in tempi molto rapidi. La nascità di questa nuova comunità italiana, consentirà finalmente una possibilità di condivisione e confronto anche nella nostra lingua, e questo non potrà che rendere ancora più interessante questo ambiente di sviluppo.

Alla luce della mia esperienza posso sicuramente consigliare Lazarus a tutti coloro che cercano un ambiente RAD efficiente e moderno, basato su un linguaggio, il Pascal, che ritengo sempre e comunque più attuale che mai, un ambiente che può contare su un numero sempre maggiore di componenti disponibili in grado di soddisfare le esigenze più diverse, dalla generazione di files PDF all'invio di mails, dalla crittografia all'accesso ai databases solo per citarne alcuni.

Forse non farà "moda", ma a mio parere è un eccellente ambiente di sviluppo.

Stefano Cortelli
E-Mail: info@studiocortelli.com

Sito: http://www.studiocortelli.com

Snapshot del progetto:

Questo brevissimo articolo serve a specificare la differenza che c'è tra assegnare e confrontare. L'assegnazione significa dare un valore ad una variabile, ad esempio:
Variabile1:=5; oppure Variabile1:=Variabile2;. Mentre confrontare significa verificare se due valori o variabili sono uguali, ad esempio Variabile1=Variabile2. Generalmente queste ultime stanno all'interno di condizioni. Come si può ovviamente notare per assegnare usiamo := mentre per confrontare se è uguale usiamo =

Nel campo della programmazione si presenta quasi quotidianamente la necessità di eseguire lo stesso blocco di codice (per blocco di codice si intende una o più righe di codice) per un numero di volte variabile. Facciamo un esempio se necessitaste di fare un programma che scrive per tre volte la stessa parola voi cosa fareste? In base alle conoscenze fino ad ora acquisite fareste una cosa del tipo (ipotizzando che la parola sia ciao):

write('ciao ciao ciao');

oppure

write('ciao');

write('ciao');

write('ciao');

Così facendo però se si presenta la necessita di scriverlo 4,5,N volte ad ogni necessità dovreste cambiare il codice del programma e poi ricompilarlo, con la conseguente perdita di tempo e la visibile imperizia da parte vostra. Per ovviare a questi problemi esistono i cosiddetti cicli, che sono tre.

Il primo è il ciclo for, che ha la seguente sintassi:

for variabile:=assegnazione to IndiceMassimo do

begin

…

...

end;

Come si può dedurre se noi volessimo stampare i numeri da 1 a 15 ci basterebbe scrivere queste poche righe di codice:

for i:=1 to 15 do

begin

writeln('Numero: ', i);

end;

Ovviamente la variabile i deve essere stata dichiarata precedentemente come integer.

Se si volessero stampare numeri da 1 a N basta sostituire il 15 con una variabile che verrà valorizzata da tastiera, così:

write('Fino a quale numero vuoi stampare? ');

readln(IndiceMax);

for i:=1 to IndiceMax do

begin

writeln('Numero: ', i);

end;

In questo modo è possibile stampare da 1 a un numero N senza dover modificare e ricompilare ogni volta il programma.

Il secondo ciclo che andremo a vedere è il cosidetto "repeat until". La sintassi del suddetto ciclo è la seguente:

repeat

…;

…;

until(Condizione);

Adesso replicheremo l'esempio di prima, ovvero stampare i numeri da 1 a 15, per capire meglio come si usa questo ciclo.

i:=1;

repeat

writeln('Numero: ', i);

i:=i+1;

until(i>15);

Come si può osservare la condizione è legata alla variabile i che deve essere valorizzata prima dell'esecuzione del ciclo. Un'altra cosa da notare è che l'esecuzione del programma esce dal ciclo quando la condizione è vera, come in questo caso che smette di ciclare solo quando la variabile i diventa maggiore di 15. La terza cosa ovvia da notare è che la verifica della condizione è al fondo dell'esecuzione del ciclo, quindi questo vuol dire che le righe di codice contenute all'interno del "repeat until" vengono eseguite almeno una volta.

Il terzo e ultimo ciclo è quello chiamato "while", la sua sintassi è la seguente:

while (Condizione) do

begin

…;

…;

end;

per capire meglio come si usa proseguiremo riscrivendo il codice di prima che stampa i numeri da 1 a 15.

i:=1;

while(i<=15)do

begin

writeln('Numero: ', i);

i:=i+1;

end;

In questo caso la prima cosa che dovrebbe saltare all'occhio è che la condizione è in testa e quindi se non è verificata il codice contenuto all'interno del ciclo non viene eseguito. La seconda osservazione da notare è che esce dal ciclo quando la condizione si rivela falsa.

Come si può intuire i cicli sono fondamentali per scrivere programmi di qualsiasi genere.