Progresul hardware, episodul 30: Pregătirea unei noi mari reforme algoritmice (PUTERNUM)

În această postare o să pun niște cod scris prin acea toamnă a lui 2017, când noua prefacere a algoritmilor pentru numere era în faza de schelet mintal.

A fost mai mult un cod de încercare, fără să ajungă mai apoi efectiv implementat în programele numerice în forma asta - l-am făcut atunci când încercam să îmi reprezint în minte cum ar trebui construite și abordate matricile cu puteri de factori primi pentru numere.

În plus, continuam încă să tratez preferențial primele trei numere prime impare (3, 5 și 7), așa încât mai jos apar referiri la toate cele trei, începând, desigur, cu... trei.

Iar acel 348 de la primele rânduri voia să desemneze numărul maxim de factori primi care puteau apărea la puterea 2 sau mai sus, în componența numerelor mari (adică în descompunerea lor în produs de puteri de factori primi).

*
 #include <stdio.h>
 #include <gmp.h>
 #define H 348

 int main() {

     mpz_t trei[147], cinci[68], sapte[50];
     int b[H];
   
     FILE *F1 = fopen("/PUTERITOT.TXT", "a");
     int PP = ftell(F1);
     fclose(F1);
     F1 = fopen("/PUTERITOT.TXT", "r");
   
     char t;
     int ind[H];
     int i = 0, j;
   
    for(j = 0; j < 147; j++)
        mpz_init(trei[j]);
      
    for(j = 0; j < 68; j++)
        mpz_init(cinci[j]);
      
    for(j = 0; j < 50; j++)
        mpz_init(sapte[j]);
   
     while(1) {
        j = 3;
        fscanf(F1, "%c", &t);
        if(t == ' ') --j;
        if(!j)
            fscanf(F1, "%d", &ind[i++];
      
        if(t == '\n')
            j = 3;
          
        if(ftell(F1) == PP)
            break;
     }
   
     fclose(F1);
   
     FILE *F2 = fopen("/PRIME2.TXT", "r");
     for(i = 0; i < H; i++)
        gmp_fscanf(F2, "%Zd", &b[i]);
   
    fclose(F2);
   
     mpz_t xe, g;
     mpz_init(xe);
     mpz_init(g);
   
     F1 = fopen("/TREI.TXT", "w");
     F2 = fopen("/SUM3.TXT", "w");
   
     mpz_set_ui(xe, 1);
   
     for(i = 0; i < 147; i++) {
        mpz_mul_ui(xe, xe, 3);
        mpz_mul_ui(g, xe, 3);
        mpz_tdiv_q_2exp(g, g, 1);
        gmp_fprintf(F1, "%Zd\n", xe);
        gmp_fprintf(F2, "%Zd\n", g);
     }
   
     fclose(F1);
     fclose(F2);
     F1 = fopen("/CINCI.TXT", "w");
     F2 = fopen("/SUM5.TXT", "w");
   
     mpz_set_ui(xe, 1);
     for(i = 0; i < 68; i++) {
        mpz_mul_ui(xe, xe, 5);
        mpz_mul_ui(g, xe, 5);
        mpz_tdiv_q_2exp(g, g, 2);
      
        gmp_fprintf(F1, "%Zd\n", xe);
        gmp_fprintf(F2, "%Zd\n", g);
     }

     fclose(F1);
     fclose(F2);
     F1 = fopen("/SAPTE.TXT", "w");
     F2 = fopen("/SUM7.TXT", "w");
   
     mpz_set_ui(xe, 1);
     for(i = 0; i < 50; i++) {
        mpz_mul_ui(xe, xe, 7);
        mpz_mul_ui(g, xe, 7);
        mpz_divexact_ui(g, g, 6);
      
        gmp_fprintf(F1, "%Zd\n", xe);
        gmp_fprintf(F2, "%Zd\n", g);
     }
   
     fclose(F1);
     fclose(F2);
   
     F1 = fopen("/INDPUT.TXT", "w");
     FILE *F2 = fopen("INDSUM.TXT", "w");
   
     for(i = 0; i < H; i++) {//H scotfactizat.
        if(b[i] < 10) continue;
        mpz_set_ui(xe, 1);
      
        for(j = 0; j < ind[i]; j++) {
            mpz_mul_ui(xe, xe, b[i]);
            mpz_mul_ui(g, xe, b[i]);
            mpz_divexact_ui(g, g, b[i]-1);
            gmp_fprintf(F1, "%Zd ", xe);
            gmp_fprintf(F2, "%Zd ", g);
        }
      
            fputc('\n', F1);
            fputc('\n', F2);
     }
   
     fclose(F1);
     fclose(F2);
 }
 

 VERIF357(A, B, 3, 1, trei, sum3);
 VERIF357(A, B, 5, 1, cinci, sum5);
 VERIF357(A, B, 7, 1, sapte, sum7);

 void VERIF357(mpz_t A, mpz_t B, gmp_ui c, int i, mpz_t *div, mpz_t *sum) {
    if(mpz_divisible_ui_p(A, c)) {
        while(mpz_divisible_p(A, div[i])) i++;
        mpz_mul(B, B, sum[--i]);
    }
 }
**

Terminăm aici prima secțiune a algoritmului de încercare, cea care se referea strict la numerele 3, 5 și 7, ca să vedem mai jos cum începeam să-mi imaginez accesarea efectivă a matricilor pentru puterile prime, care, desigur, erau matrici deoarece pentru fiecare factor prim era alocat un vector de puteri (pornind de la puterea 0, recte numărul 1), iar mai mulți vectori strânși la un loc se cheamă că ei compun o matrice.

Concret, aici, este vorba despre accesarea generică a unui astfel de vector din interiorul matricii, transmis desigur ca parametru cu index de poziție în matrice, către antetul funcției VERIFSUM (sau VERIFSUM2).

*
 Sau VERIFSUM(A, B, b[d], 1, div[d], sum[d]);//d e în zona de K

 Pentru zona de H-K:

 void VERIFSUM2(mpz_t A, mpz_t B, gmp_ui c, int i, gmp_ui *div, gmp_ui *sum) {
    if(mpz_divisible_ui_p(A, c)) {
        while(mpz_divisible_ui_p(A, div[i])) i++;
        mpz_mul_ui(B, B, sum[--i]);
    }
   
    VERIFSUM2(A, B, b[d2], 1, div1[d2], div2[d2]);
   
    Pentru peste H, poate să rămână restul.
 }
 **