Sortarea elementelor unui șir

Se consideră șirul x1, x2, x3, ..., xk, ...., xn cu n componente și se pune problema sortării descrescătoare a elementelor șirului, astfel încât la revenirea în programul principal  x1 > x2> x3> ...>xk> ...., >xn. Variabila IK0 dacă șirul era deja sortat și IK=1 dacă s-a efectuat sortarea.
Subprogramul este:

         SUBROUTINE MAXIM (X,N,IK)
         IK=0
         DO 10 I=1,N-1
         IF(X(I).LT.X(I+1)) GO TO 20
10     CONTINUE
         GO TO 40
 20    IP=0
         DO 30 I=1,N-1
         IF(X(I).GE.X(I+1)) GO TO 30
         AUX=X(I+1)
         X(I+1)=X(I)
         X(I)=AUX
         IP=IP+1
30    CONTINUE

         IF(IP.NE.0) GO TO 20

40     CONTINUE
          RETURN
         END


(25 decembrie 2017)
Acest program nu este testat că nu am un compilaor FORTRAN IV...

Ștergerea unui element din șir

Se consideră șirul x1, x2, x3, ..., xk, ...., xn cu n componente și se pune problema ștergerii elementului xk din șir, ceea ce va duce la faptul că șirul va avea n-1 elemente după aceea. Subprogramul verifică dacă poziția elementului ce trebuie șters este în șir. Variabila de stare IK=1 dacă ștergerea s-a efectuat sau IK=0 în caz contrar din cauză că elementul ce trebuie șters nu se află în interiorul șirului. Noul șir are NN componente.

         SUBROUTINE MAXIM (X,N,K, NN, IK)
         IK=0
         IF(K.LT.1.OR.K.GT.N) GO TO 20
         DO 10 I=K,N-1
         X(K)=X(K+1)
10     CONTINUE
         IK=1
         NN=N-1
20     CONTINUE
         RETURN
         END

Ștergerea unui element din șir are două abordări. Una distruge șirul, iar a doua crează un nou șir în care elementul șters dispare și lungimea șirului este maim mică cu 1.

         SUBROUTINE MAXIM (X,YN,K, NN, IK)
         IK=0
         IF(K.LT.1.OR.K.GT.N) GO TO 20
         DO 10 I=1,K-1
         Y(K)=X(I)

10     CONTINUE
         DO 20 I=K,N-1
         Y(K)=X(K+1)
10     CONTINUE
         IK=1
         NN=N-1
20     CONTINUE
         RETURN
         END

(24 decembrie 2017)

Compararea de matrice

dacă se dau două matrice cu același număr de linii și de coloane, a le compara înseamnă a vedea dacă au toate elementele corespondente de pe linii și de pe coloane identice. Subprogramul are o variabilă de stare IK=0 dacă matricele sunt diferite și IK=1 dacă matricele sunt identice.
Subprogramul este:

         SUBROUTINE COMPAR (A,B,M,N,IK)
         IK=0.
         DO 10 I=1,M

         DO 10 J=1,N
         F(A(I,J).NE.B(I,J)) GO TO 20

10     CONTINUE

         IK=1

20     CONTINUE

         RETURN
         END

(24 decembrie 2017)

Înmulțirea a două matrice

Dacă se dă matricea A cu m linii și n coloane, pentru a fi înmulțită cu matricea B, această matrice B trebuie să aibă n linii și k coloane, iar matricea rezultate C va avea m linii și k coloane. Subprogramul va fi:

         SUBROUTINE PROMAT (A,B,C,M,N,K)
         DO 20 I=1,M

         DO 20 J=1,K

         CIJ=0.

         DO 10 L=1,N
10     CIJ=CIJ+A(I,L)*B(L,J)

         C(I,J)=CIJ

20     CONTINUE

         RETURN
         END

A fost folosită variabila CIJ pentru a nu referi de prea multe ori C(I,J) a cărei adresă presupune niște calcule ce necesită oarece cicluri mașină și în acest fel se execută mai repede programul care ar lucra cu o matrice cu mii de linii și mii de coloane.

Înmulțirea a două matrice așa cum este dată aici nu conține și variabila de stare ca să se verifice dacă matricile îndeplinesc condiția ca ele să se înmulțească, lucru care ar fi presupus ca lista de parametrii să fie cu mult mai bogată, să conțină separat numărul de linii și numărul de coloane pentru cele trei matrice.

(24 decembrie 2017)

Construirea transpusei unei matrice

Dacă se dă matricea A cu m linii și n coloane, pentru a construi matricea C cu n linii și m coloane  se va scrie subprogramul:

         SUBROUTINE ADMAT (A,B,C,M,N)
         SUMAT=0.
         DO 10 I=1,M

         DO 10 J=1,N
10     C(J,I)=A(I,J)

         RETURN
         END

Matricea rezultat este C având și ea tot n linii și m coloane. Se utilizează relația cji=aij .

(24 decembrie 2017)

Scăderea de matrice

Dacă se dau matricele A și B fiecare având m linii și n coloane, pentru calculul diferenței lor se va scrie subprogramul:

         SUBROUTINE ADMAT (A,B,C,M,N)
         SUMAT=0.
         DO 10 I=1,M

         DO 10 J=1,N
10     C(I,J)=A(I,J)-B(I,J)

         RETURN
         END

Matricea rezultat este C având și ea tot m linii și n coloane. Se utilizează relația cij=aij-bij .Se observă un nivel foarte ridicat de reutilizare de cod de la subrutina de adunare de matrice.

(24 decembrie 2017)

Adunare de matrice

Dacă se dau matricele A și B fiecare având m linii și n coloane, pentru calculul sumei lor se va scrie subprogramul:

         SUBROUTINE ADMAT (A,B,C,M,N)
         SUMAT=0.
         DO 10 I=1,M

         DO 10 J=1,N
10     C(I,J)=A(I,J)+B(I,J)

         RETURN
         END

Matricea rezultat este C având și ea tot m linii și n coloane. Se utilizează relația cij=aij+bij .

(24 decembrie 2017)

Concatenarea a două șiruri

Concatenarea a două șiruri presupune existența unui șir X de n componente și a unui șir Y de m componente. Va rezulta un șir Z de n+m componente. Vom face ipoteza că n+m nu trebuie să fie mai mare de 1000. Variabila IK returnează 1 dacă s-a efectuat concatenarea și IK=0 dacă operația nu s-a efectuat. Variabila K arată numărul de componente al șirului Z concatenat.
Subprogramul este:
         SUBROUTINE CONCAT (X,N,Y,M,Z,K)
         IF(((M+M).LT.0).OR.(M+N).GT.1000) GO TO alfa
         K=0
         DO 10 I=1,N
         Z(K)=X(I)
         K=K+1
10     CONTINUE
         DO 20 I=1,N
         Z(K)=Y(I)
         K=K+1
20     CONTINUE
         RETURN
         STOP

(24 decembrie 2017)

Aflarea poziției zilei în an

Aflarea poziției zilei în an este un bun exercițiu pentru a inițializa un vector la definire și pentru a face calcule cu elementele sale. Ziua din an se dă sub forma ZI, LUNA, ANUL, fiecare fiind variabile de tip întreg. În FORTRAN există posibilitatea de a face acestă definire a tipurilor de date IMPLICIT. Algoritmul este simplu și presupune însumarea zilelor din lunile ce preced luna din data introdusă pe cartelă. Se verifică dacă anul este bisect pentru a aduna în loc de 28 de zile pentru februarie, 29.Subprogramul returnează IK=1 dacă s-a calculat poziția din an și IK=0 dacă din cauză că datele sunt greșite nu s-a calculat această poziție. Prin dată greșită se înțelege că luna nu este un număr întreg pozitiv mai mic strict decât 13, că ziua nu este un număr întreg strict pozitiv mai mic decât 32 și despre an că nu este un număr întreg strict pozitiv.

Subprogramul arată astfel:

           SUBROUTINE (ZI,LUNA,AN, IPOZ, IK)

           DIMENSION X(12) /31,28,31,30,31,30,31,31,30,31,30,31/

           IK=0

           IF(AN.LE.0) GO TO 30

           IF((LUNA.LE.0).OR.(LUNA.GT.12)) GO TO 30

           IF((ZI.LE.0).OR.(ZI.GT.31)) GO TO 30

           IK=1

           IPOZ=1

           ALFA=MOD(AN,4)

           IF(ALFA.EQ.0) GOTO 10

           IPOZ=0

10       DO 20 I=1,LUNA-1

20       IPOZ=IPOZ+X(I)

           IPOZ=IPOZ+X(LUNA)

30       CONTINUE

           RETURN

           STOP

           

Dacă la Compilatorul FORTRAN IV este implementată facilitatea de a avea în lista de apel a funcțiilor încorporate alte apeluri de funcții, expresia:

           IPOZ=IPOZ+X(LUNA)

s-ar fi scris:

           IPOZ=IPOZ+X(LUNA)+NOD(NOD(AN,2),2)

și nu ar mai fi fost nevoie secvența:

           IPOZ=1

           ALFA=MOD(AN,4)

           IF(ALFA.EQ.0) GOTO 10

           IPOZ=0

Neavând la dispoziție acum un compilator de FIRTRAN IV, evident nu am cum să testez această facilitate, dar așa cum sunt prezentate funcții nu-mi crează senzația că ar accepta, deși tabelul dă senzația prin modul în care este definită funcția MOD().
Aflarea poziției zilei în an este un exercițiu interesant, dar și mai interesant este de văzut care sunt diferențele față de implementarea în limbajul C++ unde definirea ZI, LUNĂ, AN se face așa cum suntem obișnuiți în scrierea curentă zz.ll.yyyy, existând posibilitatea de tratare șiruri de caractere și de conversii.

(24 decembrie 2017)

Verificarea dacă șirul este sortat

Se consideră șirul x1, x2, x3, ..., xk, ...., xn cu n componente și se pune problema vverificării dacă șirul este ordonat sau sortat crescător, caz în care varia bila de stare IK va avea valoarea 1 sau șirul este sortat descrescător, caz în care variabila IK va avea valoarea 2. În cazul în care șirul nu este ordonat, variabila OK va avea valoarea zero. Pentru a face verificarea se compară elementele consecutive xk și xk+1, ceea ce presupune ca variabila de control I în structura repetitivă să aibă valori de la 1 la N-1.

Programul scris în limbajul FORTRAN IV este:

           SUBROUTINE VERIF(X,N,IK)

           IK=0

           DO  10 I=1,N-1

           IF(X(I).GE.X(I+1)) GO TO 20

10       CONTINUE

           IK=1

           GO TO 40

20       CONTINUE

           DO  30 I=1,N-1

           IF(X(I).LE.X(I+1)) GO TO 40

10       CONTINUE

           IK=2

40       CONTINUE

           RETURN

           END

Am pus câteva instrucțiuni CONTINUE pentru a face mai clar programul, dar tot atât de bine programul mergea și fără ele.

         

(24 decembrie 2017)

Adunarea elementelor unui șir.

Dacă se consideră șirul x1, x2, x3, ..., xk, ...., xn cu n componente și se pune problema însumării elementelor sale, schema logică aferentă este:

Programul este:

         SUBROUTINE SUMA (X,N,SUM)
         SUM=0.
         DO 10 I=1,N
10     SUM=SUM+X(I)
         RETURN
         END

Fără prea multe modificări acest subprogram se transformă în subprogramul pentru calculul mediei aritmetice simple sau mediei aritmetice ponderate sau pentru calculul mediei armonice dar și pentru calculul mediei geometrice.



(23 decembrie 2017)

Minim și maxim dintr-un șir

Aflarea minimului și maximului dintr-un șir dar și a pozițiilor lor este o problemă interesantă și trebuie văzută ca un mod de agregare a subprogramelor de alflare a minimului și respectiv a maximului sau se construiește un subprogram de sine-stătător.

Varianta A: Se utilizează subprogramele existente și se agregă prin apelare.

         SUBROUTINE MAXIM (X,N,MAX,IPOZ)
         MIN=X(1)
         IPOZ=1
         DO 10 I=2,N
         IF(MAX.LE.X(I)) GO TO 10
         MAX=X(I)
         IPOZ=I
10     CONTINUE
          RETURN
         END

         SUBROUTINE MINIM (X,N,MIN,IPOZ)
         MIN=X(1)
         IPOZ=1
         DO 10 I=2,N
         IF(MIN.LE.X(I)) GO TO 10
         MIN=X(I)
         IPOZ=I
10     CONTINUE
          RETURN
         END
        SUBROUTINE MINMAX (X,N,MIN,MAX,IPOZMIN, IPOZMAX)
        CALL MINIM (X,N,MIN,IPOZMIN)
        CALL MAXIM (X,N,MAX,IPOZMAX)
         RETURN
         END
Varianta B: se preiau într-o singură subrutină prelucrările celor două surutine deja existente fără să se mai apeleze alte rutine existente în bibliotecă.

         SUBROUTINE MINMAX (X,N,MIN,MAX,IPOZMIN, IPOZMAX)
         MIN=X(1)
         IPOZMIN=1
         MAX=X(1)
         IPOZMAX=1
         DO 10 I=2,N
         IF(MIN.GE.X(I)) GO TO 10
         MIN=X(I)
         IPOZMIN=I
10     CONTINUE
         DO 20 I=2,N
         IF(MAX.LE.X(I)) GO TO 10
         MAX=X(I)
         IPOZMIN=I
20     CONTINUE
         RETURN
         END
Varianta C: se caută o îmbunătățire a variantei B prin regruparea într-o singură secvență repetitivă a tuturor prelucrărilor care au același număr de repetări și mai ales că prelucrările sunt independente.

         SUBROUTINE MINMAX (X,N,MIN,MAX,IPOZMIN, IPOZMAX)
         MIN=X(1)
         IPOZMIN=1
         MAX=X(1)
         IPOZMAX=1
         DO 20 I=2,N
         IF(MIN.GE.X(I)) GO TO 10
         MIN=X(I)
         IPOZMIN=I
10     IF(MAX.LE.X(I)) GO TO 20
         MAX=X(I)
         IPOZMIN=I
20     CONTINUE
         RETURN
         END

Cele prezentate aici sunt doar câteva considerații ii mari a programa în limbajul FORTRAN, în vremurile în care șeful de proiect gestiona la nivel de linie sursă ceea ce se scria și se regăsea în final într-un produs care trebuia să fie reprezentativ pentru centrul de calcul unde se producea acel text sursă, care era livrat sub formă de cartele perforate și era însoțit de imprimantă.

(23 decembrie 2017)

Maxim dintr-un șir

Se consideră șirul x1, x2, x3, ..., xk, ...., xn cu n componente și se pune problema găsirii elementului maxim și a poziției acestuia din șir.
Diagrama sau schema logică după care se scrie subprogramul este:

Ideia de subprogram apare din faptul că alegerea maximului dintr-un șir apare în numeroase probleme și deci de fiecare dată trebuie apelat un subprogram de bibliotecă și nu scrisă secvența respectivă.

         SUBROUTINE MAXIM (X,N,MAX)
         MAX=X(1)
         DO 10 I=2,N
         IF(MAX.LE.X(I)) GO TO 10
         MAX=X(I)
10     CONTINUE
          RETURN
         END
Dacă se dorește și aflarea poziției elementului minim subprogramului i se adaugă în lista de parametrii variabila IPOZ și ceva instrucțiuni de atribuire, după cum urmează:

         SUBROUTINE MAXIM (X,N,MAX,IPOZ)
         MAX=X(1)
         IPOZ=1
         DO 10 I=2,N
         IF(MAX.LE.X(I)) GO TO 10
         MAX=X(I)
         IPOZ=I
10     CONTINUE
          RETURN
         END
Am preferat să nu scriu acest subprogram ca subprogram funcție datorită faptului că îl voi folosi să returneze nu numai valoarea elementului maxim și și poziția pe care acesta se află. În plus, fără modificări semnificative îl modific să stabilesc și valorile maximă și minimă din șir și pozițiile acestora dacă vreau.

(14 decembrie 2017)

7 erori ale clienților

1. Clienții nu acceptă noi soluții pentru noi probleme.
2. Clienții cred că știu totul și nu se documentează în legătură cu noua aplicație.
3. Clienții se enervează prea ușor când aplicația nu le oferă ceea ce așteaptă.
4. Clienții consideră orice aplicație nouă ca fiind slabă, inutilă, greoaie și o resping.
5. Clienții vor de la o aplicație cu totul altceva decât scopul pentru care ea a fost realizată.
6. Clienții nu salvează date inițiale și sunt obligați să le reintroducă la reluări.
7. Clienții nu salvează rezultate finale și sunt obligați să reia execuția pentru a le obține.

(22 decembrie 2017)