Geometria analitica Elemente in plan

Inca de mici desenam pe foaie diferite elemente geometrice (segmente, cercuri, patrate,), fara sa stim ca acestea joaca un rol important in matematica, avand numeroase aplicatii si in informatica. Cu timpul insa am inceput sa intelegem ca traim intr-un spatiu in care totul poate fi raportat la unul sau mai multe dintre aceste elemente. Mai tarziu studiam asa-numita geometrie analitica, prezentand-o ca fiind unul dintre sectoarele matematicii, in care punctul este elemental central. Insa, prin geometrie analitica se intelege mult mai mult, iar in acest articol voi incerca sa va introduc in tainele sale. Sa pornim deci la drum!

Coordonate pe o dreapta
Definitie. Se numeste axa o dreapta pe care s-a fixat o origine si un sens de parcurgere. Fiecarui numar real n i se asociaza cate un punct al dreptei astfel : numarului 0 i se asociaza originea axei ; numarului pozitiv a i se asociaza punctul A al semiaxei "pozitive" , pentru care OA=a ; numarului negativ b i se asociaza punctul B al semiaxei "negative", pentru care OB=b; Asadar, pozitia unui punct A pe axa este unic determinata daca se cunoaste marimea segmentului

OA =x, abscisa punctului A. Reciproc, oricarui punct A ce apartine dreptei ii corespunde o abscisa bine determinata.

____

Coordonate in plan
Pentru fixarea pozitiei unui punct in plan nu este de ajuns o singura axa; este necesar sa se foloseasca doua axe, care se intalnesc intr-un punct O (punct ce constituie originea celor doua axe) si care de obicei sunt perpendiculare. Sensul lor (al axelor) se alege, in mod obisnuit, asa cum arata sagetile din urmatoarea figura: y P M | N x

Marimea segmentului ON=x reprezinta abscisa punctului M, iar OP=y ordonata lui. Amandoua la un loc se numesc coordonatele punctului M. Se noteaza prescurtat M(x,y).

Punctele pot fi memorate in cadrul unei structuri de tip PUNCT, astfel: #include<iostream.h> typedef struct punct { float x,y; }; void citire(punct &p) //aceasta functie realizeaza citirea coordonatelor unui punct in plan { cout<<("abscisa este: "); cin>>p.x; cout<<("ordonata este: "); cin>>p.y; } void main() { punct a; citire(a); }

Dreapta in plan. Segmente de dreapta

Ecuatia dreptei in plan Dupa cum se stie, o dreapta este determinata in mod unic prin doua puncte distincte ale sale. In plan, o dreapta poate fi descrisa in diferite moduri : Ecuatia carteziana generala a unei drepte : ax+by+c=0 Observam ca ecuatia are 3 parametrii: a, b si c. Doar atunci cand toti cei trei parametrii sunt cunoscuti putem afirma ca dreapta este complet definita. Daca a=0 (sau altfel spus y=-c/b=constant), atunci dreapta este paralela cu axa Ox, iar daca b=0 (x=-c/a=ct) dreapta este paralela cu axa Oy. Cei doi parametrii nu pot fi simultan nuli. Daca, din punct de vedere geometri,c directia unei drepte se poate da prin unghiul pe care acesta il face cu sensul pozitiv al axei Ox, din punct de vedere al geometriei analitice, pentru nevoile de calcul, directia se da prin una din functiile trigonometrice ale unghiului . Cea mai folosita este tg=-a/b, care se noteaza de obicei cu m si se numeste coeficient unghiular sau panta dreptei.

Pentru fixarea pozitiei unei drepte nu este suficient sa cunoastem coeficientul ei unghiular, ci mai trebuie un punct al dreptei. Cu aceste doua elemente, pozitia dreptei este determinata. Structura care memoreaza o dreapta in C++ poate arata astfel : typedef struct dreapta {float a,b,c ;}; dreapta d; Atunci d.a, d.b, respectiv d.c sunt parametrii d. Ecuatia dreptei determinate de un punct si o directie. Fie M(x0,y0) punctul dat si directia definita prin coeficientul unghiular m=tg (unghiul dreptei cu axa Ox). Atunci obtinem usor ca y-y0=m(x-x0). Pe baza acestei formule, se obtine si ecuatia dreptei date prin coeficientul unghiular si ordonata la origine: y=mx+n. Avem m=tg, iar n este ordonata punctului in care dreapta intersecteaza axa Oy. Ecuatia dreptei atunci cand se cunosc coordonatele a doua puncte distincte de pe dreapta respectiva. Formula pe baza careia poate fi determinata este urmatoarea : x y 1 x1 y1 1 =0 x2 y 2 1 unde (x1,y1) si (x2,y2) sunt coordonatele celor doua puncte. Altfel spus, a=y1-y2, b=x2-x1, c=x2y1-y2x1. Ne propunem acum sa scriem un program in care sa calculam coeficientii a,b,c ai dreptei d (cand stim doua puncte prin care trece dreapta). #include<iostream.h> typedef struct punct {float x,y;}; typedef struct dreapta {float a,b,c;}; void citire(punct &p) { cout<<("abscisa este: "); cin>>p.x; cout<<("ordonata este: "); cin>>p.y; }

void coeficienti (punct m,punct n, dreapta &d) { d.a=m.y-n.y; d.b=n.x-m.x; d.c=m.x*n.y-n.x*m.y; } void main() { punct m,n; dreapta d; citire(m); citire(n); coeficienti(m,n,d); }

Ecuatia dreptei prin taieturi. Se numesc taieturi punctele unde o dreapta taie axele de coordonate. Coordonatele acestor puncte sunt coordonatele la origine ale dreptei (daca A(a,0) si B(0,b) sunt cele doua puncte pe axe,atunci a este abscisa la origine si b ordonata la origine). x y Ecuatia dreptei devine : + = 1 . a b Sa verificam acum daca un punct M apartine unei drepte, a carei ecuatii este data prin taieturi.

int apartine (punct M,dreapta d) { if(M.x/d.a+M.y/d.b==1) return 1; //adica punctual apartine dreptei else return 0; //punctual nu apartine dreptei } Amintim faptul ca in acest caz, structura dreapta este declarata astfel: typedef struct dreapta {float a,b;};
Pozitiile relative ale dreptelor in plan Intersectia a doua drepte. Fiind date ecuatiile a doua drepte a1x+b1y+c1=0 si a2x+b2y+c2=0, daca ele sunt concurente, atunci coordonatele punctului de intersectie sunt :

x=-

c1b 2 c 2b1 a1c 2 a 2c1 , y=, a1b 2 a 2b1 a1b 2 a 2b1

cu conditia ca a1b2-a2b10 (pentru ca altfel dreptele nu sunt concurente).

void pct_intersectie (punct &M, dreapta d1,dreapta d2) { if(d2.a*d1.b-d1.a*d2.b==0) cout<<"Dreptele sunt paralele! Ele nu au nici un punct de intersectie!"; else { M.x=-(d1.c*d2.b-d1.b*d2.c)/(d1.a*d2.b-d2.a*d1.b); //abscisa punctului de intersectie M.y=-(d1.a*d2.c-d2.a*d1.c)/(d1.a*d2.b-d2.a*d1.b); //ordonata punctului de intersectie } } a1 b1 c1 = , sau, altfel spus, daca ele au aceeasi a 2 b2 c2 panta si exista un punct necomun (de exemplu punctul de intersectie cu axa Ox sau Oy). a1 b1 c1 = = , sau altfel spus, daca au doua puncte Drepte confundate. Doua drepte coincid daca a 2 b2 c2 comune. Unghiul determinat de doua drepte. Presupunem dreptele de panta m1, respectiv m2, si ungiul dintre ele. Atunci m 2 m1 . tg= 1 + m1m 2 Daca dreptele sunt date sub forma generala, atunci Drepte paralele. Doua drepte sunt paralele daca a1b 2 a 2b1 . a1a 2 + b1b 2 Drepte perpendiculare. Doua drepte sunt perpendiculare daca m1m2=-1, respectiv a1a2+b1b2=0. tg=
Pozitiile punctelor fata de o dreapta

Punctele care satisfac ecuatia unei drepte se vor afla pe dreapta respectiva. Pentru celelalte, valoarea expresiei ax+by+c va fi nenula. In functie de semnul acestei valori putem stabili semiplanul in care se afla punctul respectiv. Am putea spune ca valoarea este pozitiva pentru punctele situate deasupra dreptei, iar pentru cele care se afla sub dreapta valoarea este negativa. Asadar, putem spune ca punctele ce se afla de aceeasi parte a dreptei verifica inecuatia (ax1+by1+c)(ax2+by2+c)>0. int acelasi_semiplan (punct M,punct N, dreapta d) { if ((d.a*M.x+d.b*M.y+c)* (d.a*N.x+d.b*N.y+c)>0) return 1;//punctele se afla in acelasi semiplan else if ((d.a*M.x+d.b*M.y+c)* (d.a*N.x+d.b*N.y+c)<0) return 0; //sunt in semiplane diferite }

Stim ca daca (d.a*M.x+d.b*M.y+c)=0 (respectiv (d.a*N.x+d.b*N.y+c)=0 ) atunci punctul M (respectiv N) se afla pe dreapta d, si de aceea nu am mai considerat si acest caz.
Conditia de coliniaritate a 3 puncte
x1 y1 1 y 2 1 =0 y3 1

A(x1,y1), B(x2,y2), C(x3,y3) sunt coliniare daca

x2 x3

int coliniare (punct A,punct B,punct C) { if(A.x*(B.y-C.y)-A.y*(B.x-C.x)+B.x*C.y-C.x*B.y==0) return 1; //punctele sunt coliniare else return 0 ; }

Distanta de la un punct la o dreapta Fie punctul M(x0,y0) si dreapta (d) : ax+by+c=0 untr-un sistem ortonormat xOy. Distanta de la punctul M la dreapta (d) este data de formula:

d(M,d)=

ax 0 + by 0 + c a2 + b2

float distanta (punct M, dreapta d) { float dist=abs(d.a*M.x+d.b*M.y+c)/sqrt(d.a*d.a+d.b*d.b) ; return dist; }

Unghiul dintre doua drepte Sa consideram cele doua drepte ca fiin 2 vectori AB si CD din plan. Fie x1,y1 proiectiile primului vector pe cele doua axe de coordonate si x2,y2, proiectiile celui de-al doilea vector pe axe. Fie L1,L2 lungimile celor doi vectori si unghiul dintre cei doi vectori. x1 x 2 + y 1 y 2 x1 y 2 + x 2 y 1 , iar sin()= . Atunci cos()= L1 L 2 L1 L 2

Segmentul
Dupa cum bine stim, se numeste segment o dreapta(o linie) ce uneste doua puncte. Punctul de plecare al unui segment este originea sa, iar punctul unde se termina este extremitatea. Lungimea sa este diferenta in modul dintre abscisa extremitatii si abscisa originii, iar abscisa mijlocului segmentului este x=(x1+x2)/2 , (x1 si x2 fiind abscisele originii, respectiv extremitatii). Sa presupunem ca avem o problema cu segmente. Acestea pot fi memorate dupa cum urmeaza :

#include<conio.h> #include<stdio.h> #include<iostream.h> #define Max 100 typedef struct punct { float x,y; }; typedef struct segment { punct a,b; }; void citire_punct (punct &p) { cout<<("Introduceti abscisa punctului: "); cin>>p.x; cout<<("Introduceti ordonata punctului: "); cin>>p.y; } void citire_segment (segment &s) { cout<<("Coordonatele primului punct:\n"); citire_punct(s.a); cout<<("\n"); cout<<("Coordonatele celui de-al doilea punct:\n"); citire_punct(s.b); } float x(punct p) { return p.x; } float y(punct p){ return p.y; } void main() { segment s; citire_segment(s); cout<<x(s.a); //prin x(s.a) se intelege abscisa originii segmentului s cout<<y(s.a); //prin y(s.a) se intelege ordonata originii segmentului s cout<<x(s.b); //se va scrie abscisa extremitatii segmentului cout<<y.(s.b); //ordonata extremitatii segmentului

Din punctul de vedere al geometriei analitice, vom studia, in legatura cu segmentele, urmatoarele probleme: a) distanta dintre doua puncte (lungimea unui segment) b) inclinarea unui segmente M1M2 fata de axa Ox c) punctul ce imparte un segment intr-un raport dat d) intersectia a doua segmente a) Distanta dintre doua puncte. Fie M1(x1,y1) si M2(x2,y2) cele doua puncte (extremitatile segmentului). Atunci lungimea segmentului M1M2= ( x 2 x1) 2 + ( y 2 y1) 2 Sa vedem acum cum arata programul realizat in C++ ce calculeaza aceasta distanta.

#include<iostream.h> #include<math.h> typedef struct punct {float x,y;}; float distanta (punct a,punct b) //calculam distanta dintre doua puncte in plan(date ca parametrii) { float d; d=sqrt(pow(a.x-b.x,2)+pow(a.y-b.y,2)); return d; } void citire(punct &p) //aceasta functie realizeaza citirea coordonatelor unui punct in plan { cout<<("abscisa este: "); cin>>p.x; cout<<("ordonata este: "); cin>>p.y; } void main() { punct a,b; citire(a); citire(b); cout<<distanta(a,b); } Utilizand aceasta formula putem decide daca un punct se afla sau pe un segment. Sa presupunem ca avem un segment cu extremitatile in punctele de coordonate M(x1,y1) si N(x2,y2) si un al treilea punct de coordonate P(x3,y3). Este evident ca, pentru a verifica daca cel de-al treilea punct apartine segmentului,

este suficient sa calculam distantele de la M si N la P, si apoi sa comparam suma lor cu lungimea segmentului. int apartine (punct M, punct N, punct P) { float d1,d2,l; d1=sqrt(pow(M.x-P.x,2)+pow(M.y-P.y,2)); d2=sqrt(pow(N.x-P.x,2)+pow(N.y-P.y,2)); l=sqrt(pow(M.x-N.x,2)+pow(M.y-N.y,2)); if(d1+d2==l) return 1; //punctul P apartine segmentului MN else return 0; //punctual P nu apartine segmentului MN } b) Inclinarea segmentului M1M2 fata de axa Ox este data prin tg (unde este unghiul facut de M1M2 cu axa Ox, iar x1x2). y 2 y1 . tg= x 2 x1 cu m. Acest numar tg se numeste coeficient unghiular sau panta dreptei M1M2 si de obicei se noteaza

float panta (punct a,punct b) { float m; m=(b.y-a.y)/(b.x-a.x); return m; } In particular, daca dreapta este definita de originea O(0,0) si un punct M(x,y), atunci panta y dreptei OM este m=tg= . x c) Punctul ce imparte un segment intr-un raport dat. Fie M(x,y), M M1M2 , punctul ce imparte MM 1 = k , unde MM1 si MM2 sunt segmente orientate (k<0 cand M M1M2, segmentul M1M2 astfel : MM 2 deoarece MM 1 ,si MM 2 au sensuri contrare si k>0 pentru M exterior segmentului M1M2). Atunci x1 kx 2 y1 ky 2 si y= . x= 1 k 1 k
_____ ______

Pe baza acestei formule, putem afla si coordonatele punctului situat la mijlocul segmentului M1M2 (fie _____ _____ MM 1 = 1 , iar MM 1 ,si MM 2 au sensuri contrare) si deci acesta M). In acest caz, k=-1 (pt ca MM 2 x1 + x 2 y1 + y 2 , yM= . xM= 2 2 void coord_mijloc(punct a,punct b, punct &m) { m.x=(a.x+b.x)/2; m.y=(a.y+b.y)/2; } d) Intersectia a doua segmente. Fie AB si CD doua segmente. Pentru a se intersecta trebuie ca : AB si CD sa nu fie paralele Punctele A si B sa nu se afle in acelasi semiplan fata de dreapta CD ( doua puncte M(x1,y1) si N(x2,y2) se afla in acelasi semiplan fata de o dreapta d: ax+by+c=0 daca si numai daca (ax1+by1+c)(ax2+by2+c)0 ) Punctele C si D sa nu se afle in acelasi semiplan fata de dreapta AB

Aria unui triunghi

x1 1 Daca A(x1,y1), B(x2,y2), C(x3,y3), aria triunghiului ABC este SABC= D , unde D= x 2 2 x3 y1 1 y2 1 . y3 1

float aria(punct A, punct B, punct C) { S=abs(A.x*(B.y-C.y)-A.y*(B.x-C.x)+B.x*C.y-C.x*B.y)/2 ; return S ; }

Punct in interiorul unui triunghi

Una dintre problemele cu care ne-am putea intalni in materie de geometrie in plan, este verificarea daca un punct Q apartine sau nu interiorului unui anumit triunghi, cu colturile in punctele M,N si respectiv P.

Q N P

O prima solutie ar fi sa calculam ariile triughiurilor MNQ, MPQ, NMQ, si MNP si apoi sa verficam daca primele trei insumate sunt egale cu aria lui MNP. Asdar, rezolvarea este una simpla :

int apartine_triunghiului (punct M, punct N, punct P, punct Q) { float S1,S2,S2,S ; S1=aria(M,N,Q); //am folosit aici functia de calculare a ariei unui triunghi, prezentata mai sus S2=aria(M,P,Q); S3=aria(N,M,Q); S=aria(M,N,P); if(S1+S2+S3==S && S1!=0 && S2!=0 && S3!=0) return 1; //daca una dintre S1,S2,S3 ar fi 0,
punctual Q ar coincide cu unul din varfurile triunghiului, si deci nu s-ar afla in interiorul acestuia.

//atunci

else return 0; } O a doua solutie a proplemei, ar fi urmatoarea: sa luam fiecare varf al triunghiului si sa verificam daca acesta si punctul Q se afla de aceeasi parte a dreptei opuse (adica pentru punctul M sa verificam daca acesta si punctul Q se afla de aceeasi parte a dreptei determinate de punctele P si N,). Nici aceasta solutie nu pare a fi una complicata, in conditiile in care am prezentat mai sus pozitiile punctelor fata de o dreapta, precum si ecuatia unei drepte determinate de doua puncte ale acesteia. int apartine_triungiului(punct M, punct N, punct P, punct Q) { dreapta d1,d2,d3; coeficienti (M,N,d1); coeficienti (M,P,d2); coeficienti (N,P,d3); if (acelasi_semiplan(P,Q,d1) && acelasi_semiplan(N,Q,d2) && acelasi_semiplan(M,Q,d3))return 1; else return 0; } Amintim faptul ca functia coeficienti(A,B,d) stabileste coeficientii a,b,c ai dreptei d, care trece prin punctele A si B, iar functia acelasi_semiplan(A,B,d) verifica daca punctele A si B se afla de aceeasi parte a dreptei d. Problema poate fi extinsa la orice alt poligon, (patrat, pentagon,), caci ideea de rezolvare ramane aceeasi.

Convexitate
Aflarea pozitiei unui punct fata de o dreapta ne este foarte folositoare, intrucat intalnim adesea probleme care se pot rezolva folosind aceasta idee. Un exemplu, este cel dat mai sus (verificarea daca un

punct este sau nu in interiorul unui triunghi), iar acum sa ne indreptam atentia asupra altei probleme: verificarea daca un poligon este sau nu convex. Asadar, avand un poligon cu n varfuri (fie acestea A1,A2,A3,An, luate in ordine trigonometrica), ne dorim sa verificam convexitatea sa. O solutie ar fi aceasta: pentru fiecare doua varfuri consecutive (An,An+1) ale poligonului, aflam pozitia celorlalte varfuri, fata de dreapta AnAn+1. Doar daca varfurile se afla de aceeasi parte dreptei, poligonul va fi convex, altfel nu. Sa realizam o functie care verfica convexitatea unui poligon. int convex(punct A[100], int n) //A[i] este punctul Ai, iar n numarul de varfuri { int i,j,ok=1,nr; dreapta d; for(i=1;i<n && ok;i++) { coeficienti(A[i],A[i+1],d); nr=0; for(j=1;j<=n;j++) if(i!=j && i+1!=j) if(d.a*A[j].x+d.b*A[j].y+d.c>0) nr++; if(nr==n-2 || nr==0) ok=1; else ok=0; } //mai ramane sa verificam acelasi lucru si pentru punctele A1,An coeficienti(A[n],A[1],d); nr=0; for(j=1;j<=n;j++) if(j!=1 && j!=n) if(d.a*A[j].x+d.b*A[j].y+d.c>0) nr++; if(nr==n-2 || nr==0) ok=1; else ok=0; if(ok==1) return 1; else return 0; } O a doua solutie ar fi ca pentru fiecare 3 termeni consecutivi (An,An+1,An+2) sa calculam x1 y1 1 determinantul x 2 y 2 1 , unde x1,y1,x2,y2,x3,y3 sunt coordonatele celor trei puncte, luate in ordine x3 y 3 1 trigonometrica. Pentru ca poligonul sa fie convex, trebuie ca toti acesti determinanti sa aiba acelasi semn. int convex(punct A[100],int n) { int i,j,k,l,nr=0; float D; for(i=1;i<=n;i++)

{ if(i!=n) j=i%n; //am facut aceasta atribuire pentru a nu mai fi nevoiti sa luam separate cazurile An-1AnA1, else j=n; if((i+1)!=n) k=(i+1)%n; else k=n; if((i+2)!=n) l=(i+2)%n; else l=n; D=A[j].x*(A[k].y-A[l].y)-A[j].y*(A[k].x-A[l].x)+A[k].x*A[l].y-A[l].x*A[k].y; if(D>0) nr++; } if(nr==n || nr==0) return 1; else return 0; } Problemele geometriei analitice sunt insa mult mai multe si de aceea in numarul viitor imi voi indrepta atentia asupra catorva elemente referitoare la cerc, precum si asupra geometriei analitice in spatiu.