DUzun's Web
Programare, proiecte personale, divertisment

DUzun it's ME
 
\ 15 aprilie 2025, 00:21:32 \  
Conținut

FracPoli.c

x
 
/* Fractal_Poligon */                                                                       // Program Fractal_Poligon;
/*---------------------------------------------------------------------                     //  {---------------------------------------------------------------------       
  Poligonul din 3*4^n laturi se construieste pe baza triunghiurilor                         //   Poligonul din 3*4^n laturi se construieste pe baza triunghiurilor           
  echilaterale. Fiecare latura a triunghiului se imparte in 3 segmente,                     //   echilaterale. Fiecare latura a triunghiului se imparte in 3 segmente,       
  pe cel din mijloc se construieste un alt triunghi echilateral, iar                        //   pe cel din mijloc se construieste un alt triunghi echilateral, iar          
  segmentul se elimina. La fel se procedeaza cu poligonul nou format                        //   segmentul se elimina. La fel se procedeaza cu poligonul nou format          
  de n ori.                                                                                 //   de n ori.                                                                   
  ---------------------------------------------------------------------*/                   //   ---------------------------------------------------------------------}      
                                                                                            // Uses
#include <stdio.h>                                                                          // {System,}
#include <math.h>                                                                           
#include <string.h>                                                                         
#include <conio.h>                                                                          // CRT,
#include <graphics.h>                                                                       // Graph;
/*---------------------------------------------------------------------*/                   // {---------------------------------------------------------------------}                   
/* compatibility */                                                                         // {compatibility}
#define round(x) floor( x + (x < 0 ?-0.5 : 0.5) )                                           
int upcase(int c){ int x = c&~0x20; return (x>0x40)&(x<0x5B)?x:c; }                         
/*#define upcase(c) ((c)&~0x20)*/                                                           
char buf[20];                                                                               
/*---------------------------------------------------------------------*/                   // {---------------------------------------------------------------------}                   
                                                                                            // const 
const char* comenzi = "+ / - : Nr de recursii  |  * : Directia  |  <Esc>, X : Iesire";      //    comenzi        = '+ / - : Nr de recursii  |  * : Directia  |  <Esc>, X : Iesire';
#define mult_exact 300000  /*1...4284967295*/ /*Exactitatea calculelor*/                    //    mult_exact     = 30000; { 1..65535 } {Exactitatea calculelor}
/*---------------------------------------------------------------------*/                   // {---------------------------------------------------------------------}                   
#define lamda1 ( 1  )                                                                       //    lamda1 =  1;
#define lamda2 ( 0.5) /*  1 / 2 ==  0 */                                                    //    lamda2 =  1 / 2;  {  1 div 2 =  0 }
#define lamda3 (-1.5) /* -3 / 2 == -1 */                                                    //    lamda3 = -3 / 2;  { -3 div 2 = -1 }
#define sqrt3  ((double)(1.7320508075688772935274463415059))                                //    sqrt3  = 1.7320508075688772935274463415059;
#define color RED                                                                           //    color  = Red;
const char   Blue01[8] = {153, 66, 36, 24, 90, 24, 36, 66};                                 //    Blue01: FillPatternType = (153, 66, 36, 24, 90, 24, 36, 66);
/*---------------------------------------------------------------------*/                   // {---------------------------------------------------------------------}                   
                                                                                            // Type
typedef long TCoord;                                                                        //   TCoord = longint;
/*---------------------------------------------------------------------*/                   // {---------------------------------------------------------------------}                   
                                                                                            // Var
int GD, GM;                                                                                 //   GD, GM:   integer;
char ch;                                                                                    //   ch:       char;
char nr_rec;                                                                                //   nr_rec:   byte;
int directie;                                                                               //   directie: integer;
/*---------------------------------------------------------------------*/                   // {---------------------------------------------------------------------}                   
void drow_triunghi(TCoord cx, TCoord cy, double r, char n_, int dir_);                      // procedure drow_triunghi(cx, cy: TCoord; r: real; n: byte; dir: integer);
   char n;int dir;                                                                          //     var
   TCoord gx, gy, tx, ty;                                                                   //        gx, gy, tx, ty:  TCoord;
   int ex, ey;                                                                              //        ex, ey: integer;
/*---------------------------------------------------------------------*/                   // {---------------------------------------------------------------------}                   
TCoord raport(TCoord x1, TCoord x2, double r){return round((x1+r*x2) / (1+r));};            //    function  raport(x1, x2: TCoord; r: real): TCoord; begin raport := round((x1+r*x2) / (1+r)); end;
char varf_ekil(TCoord x1,TCoord y1,TCoord x2,TCoord y2,TCoord* xv,TCoord* yv,int coef)      //    function  varf_ekil(x1, y1, x2, y2: TCoord; var xv, yv: TCoord; coef: integer): boolean;
{                                                                                           //    begin
    if((x1!=x2)||(y1!=y2)){                                                                 //      if(x1<>x2)or(y1<>y2) then begin
       *xv = round(( coef*(y1-y2)*sqrt3 + x2+x1 ) / 2);                                     //         xv := round(( coef*(y1-y2)*sqrt3 + x2+x1 ) / 2);
       *yv = round(( coef*(x2-x1)*sqrt3 + y2+y1 ) / 2);                                     //         yv := round(( coef*(x2-x1)*sqrt3 + y2+y1 ) / 2);
       return 1;                                                                            //         varf_ekil := true;
    } else {                                                                                //      end else begin
       *xv = x1;                                                                            //         xv := x1;
       *yv = x2;                                                                            //         yv := x2;
       return 0;                                                                            //         varf_ekil := false;
    };                                                                                      //      end;
};                                                                                          //    end;
/*---------------------------------------------------------------------*/                   // {---------------------------------------------------------------------}                 
void SetXYPoz(double x, double y)                                                           //    procedure SetXYPoz(x, y: real);
{                                                                                           //    begin
   gx = round(x*mult_exact);                                                                //       gx := round(x*mult_exact);
   gy = round(y*mult_exact);                                                                //       gy := round(y*mult_exact);
};                                                                                          //    end;
/*---------------------------------------------------------------------*/                   // {---------------------------------------------------------------------}                   
void drow_line_to(TCoord x, TCoord y)                                                       //    procedure drow_line_to(x,y: TCoord);
{                                                                                           //    begin
   line(ex+(gx / mult_exact),ey+(gy / mult_exact),ex+(x / mult_exact),ey+(y / mult_exact)); //      line(ex+(gx div mult_exact),ey+(gy div mult_exact),ex+(x div mult_exact),ey+(y div mult_exact));
   gx = x;                                                                                  //      gx := x;
   gy = y;                                                                                  //      gy := y;
};                                                                                          //    end;
/*---------------------------------------------------------------------*/                   // {---------------------------------------------------------------------}                   
void drow_line(TCoord x, TCoord y)                                                          //    procedure drow_line(x, y: TCoord);
                                                                                            //    { (x,y) - coordonatele punctului destinatie }
{                                                                                           //    begin
  if(n<=0){                                                                                 //      if n<=0 then begin
                                                                                            //      { Sfarsitul recursiei. Desen: ___ }
    tx = gx;                                                                                //         tx := gx;            { Pastrare pozitia de pornire  }
    ty = gy;                                                                                //         ty := gy;
    drow_line_to(x, y);                                                                     //         drow_line_to(x, y);  { Doar aici se deseneaza linia }
  } else {                                                                                  //      end else begin
                                                                                            //      { Liniile 1, 2, 3 si 4 vor fi desenate respectiv in felul urmator: _ / \_ }
   n--;                                                                                     //         dec(n);
   drow_line(raport(gx, x, lamda2), raport(gy, y, lamda2));                                 //         drow_line(raport(gx, x, lamda2), raport(gy, y, lamda2));      { Linia 1 }
   if(!varf_ekil(gx, gy, raport(gx,x,1), raport(gy,y,1), &tx, &ty, dir)) n =0;              //         if (not varf_ekil(gx, gy, raport(gx,x,1), raport(gy,y,1), tx, ty, dir)) then n :=0;
   drow_line(tx, ty);                                                                       //         drow_line(tx, ty);                                            { Linia 2 }
   drow_line(raport(tx, x, lamda1), raport(ty, y, lamda1));                                 //         drow_line(raport(tx,   x, lamda1), raport(ty,   y, lamda1));  { Linia 3 }
   drow_line(x, y);                                                                         //         drow_line(x, y);                                              { Linia 4 }
   tx = raport(x, tx, lamda3);                                                              //         tx := raport(x, tx, lamda3); { Pastrare pozitia de pornire }
   ty = raport(y, ty, lamda3);                                                              //         ty := raport(y, ty, lamda3);
   n++;                                                                                     //         inc(n);
  };                                                                                        //      end;
                                                                                            //    { (tx,ty) - coordonatele punctului de pornire }
};                                                                                          //    end;
/*---------------------------------------------------------------------*/                   // {---------------------------------------------------------------------}                   
void drow_triunghi(TCoord cx, TCoord cy, double r, char n_, int dir_)                       
{                                                                                           // begin
  n = n_; dir = dir_;                                                                       //    {  / _\ }
  dir = (dir>0)?1:-1;                                                                       //  if (dir>0) then dir := 1 else dir := -1;
  ex = round(cx);                                                                           //    ex := round(cx);
  ey = round(cy);                                                                           //    ey := round(cy);
  SetXYPoz(-dir * r * sqrt3 / 2, dir * r / 2 );                                             //    SetXYPoz(- dir * r * sqrt3 / 2, dir * r / 2 );
  drow_line(-gx, gy);                                                                       //    drow_line(-gx, gy);    { _ }
  cx = tx;                                                                                  //    cx := tx;
  cy = ty;                                                                                  //    cy := ty;
  varf_ekil(tx, ty, gx, gy, &tx, &ty, -1);                                                  //    varf_ekil(tx, ty, gx, gy, tx, ty, -1);
  drow_line(tx, ty);                                                                        //    drow_line(tx, ty);     { \ }
  drow_line(cx, cy);                                                                        //    drow_line(cx, cy);     { / }
};                                                                                          // end;
/*---------------------------------------------------------------------*/                   // {---------------------------------------------------------------------}                   
int main(void)                                                                              //
{                                                                                           // BEGIN
   clrscr();                                                                                //    ClrScr;
   GD = DETECT;                                                                             //    GD := detect;
   initgraph(&GD, &GM, "");                                                                 //    InitGraph(GD, GM, '');
   if(graphresult() != grOk) {                                                              //    if GraphResult <> grOk then begin
      GM = graphresult();                                                                   //       GM := GraphResult;
      closegraph();                                                                         //       closegraph;
      printf("Erroare initializare modul grafic!\n");                                       //       Writeln('Erroare initializare modul grafic!');
      printf("%d: %s", graphresult(), grapherrormsg(GM));                                   //       Writeln(GraphResult, ': ', GraphErrorMsg(GM));
      getch();                                                                              //       readkey;
      return 1;                                                                             //       halt(1);
   };                                                                                       //    end;
                                                                                            //    { Initializare valori }
   nr_rec   = 3;                                                                            //    nr_rec   := 3;
   directie = 1;                                                                            //    directie := 1;
                                                                                            //
   do{                                                                                      //    repeat
      clearviewport();                                                                      //       ClearViewPort;
      rectangle(0, 0, getmaxx(), getmaxy());                                                //       Rectangle(0, 0, GetMaxX, GetMaxY);                                                     
      sprintf(buf, "nr rec: %02u", nr_rec);  outtextxy(10, 10, buf);                        //       OutTextXY(10, 10,  'nr rec: '+chr(nr_rec div 10+48)+chr(nr_rec mod 10+48));            
      outtextxy((getmaxx()-strlen(comenzi)*8) / 2, getmaxy()-13,  comenzi);                 //       OutTextXY((GetMaxX-length(comenzi)*8)div 2, GetMaxY-13,  comenzi);                     
                                                                                            //                                                                                              
      drow_triunghi(getmaxx() / 2, getmaxy() / 2, getmaxy() / 7 * 3, nr_rec, directie);     //       drow_triunghi(GetMaxX div 2, GetMaxY div 2, GetMaxY div 7 * 3, nr_rec, directie);      
      setfillpattern(Blue01,color);                                                         //       SetFillPattern(Blue01,color);                                                          
      floodfill(getmaxx() / 2, getmaxy() / 2, getcolor());                                  //       FloodFill(GetMaxX div 2, GetMaxY div 2, getcolor);                                     
                                                                                            //
      ch = getch();                                                                         //       ch := ReadKey;
      switch(ch){                                                                           //       case ch of
         case '+': if(nr_rec < 12) nr_rec++;  break;                                        //       '+': if nr_rec < 12 then inc(nr_rec);
         case '-': if(nr_rec > 0)  nr_rec--;  break;                                        //       '-': if nr_rec > 0  then dec(nr_rec);
         case '*': directie = -directie;      break;                                        //       '*': directie := -directie;
      };                                                                                    //       end;
   }while( !(ch==27 || ch==13 || upcase(ch)=='X') );                                        //    until (ch = #27) or (ch = #13) or (upcase(ch) = 'X'); {<Esc> or <Enter>}
                                                                                            //
closegraph();                                                                               //    closegraph;
return 0;                                                                                   //    halt(0);
}                                                                                           // END.

Aici acumulez programe şi algoritmi interesanti alcătuiţi de mine (cu mici excepţii) pe parcursul studierii unor limbaje de programare.

Cea mai mare parte din ele sunt realizate în Pascal. 

Nu am scopul creării unui curs specializat sau a descrierii detaliate a anumitor limbaje, ci doar prezint informaţii utile, plus ceva exemple interesante...

 

Răsfoitorul de fișiere (File Browser):

Codul sursă al programelor este organizat în mape şi fişiere.

Paginile care conțin cod sursă de programe de regulă au un răsfoitor de fișiere în partea stangă a paginii reprezentat de un bloc cu titlul „File Browser”.

Pentru a vizualiza un program sau conţinutul unei mape, faceţi click pe numele fişierului / mapei. Dacă fişierul nu este textual, el se va descărca automat, iar dacă este textual, conținutul lui se va afișa într-un bloc pe centrul paginii.

Pentru a descărca un fişier, faceţi click pe dimensiunea (size) lui.

arr_d Limba / Language


 


arr_r Login
 
 
Loading...