Jump to content
saramgsilva

[C++] Projecto Polinomios

Recommended Posts

saramgsilva

Boas, alguns de voces ja deve saber que fiz um projecto sobre polinomios de grau inferior a 100, em C++, uso classes, é possivel escolher 3 tipos de polinomios: Polinomio de grau inferior a 100, monomios e polinomios de grau 2 ;

Coloquei este projecto na minha pagina pessoal: tofas.com.sapo.pt

Realizei um simples programa em C++, usando o conceito de POO

Chama-se Polinomios: Pretende-se, com este projecto, implementar um programa para manipular polinómios com grau superior ou igual a 0 e inferior a 100. Para isso, foi necessário criar um sistema que, através dos dados inseridos pelo utilizador quando necessário, seja capaz de executar diversas operações com os mesmo. Neste sentido, o programa permite realizar algumas tarefas, tais como:

* Calcular a primitiva do polinómio;

* Calcular a derivada do polinómio;

* Calcular o f(x) do polinómio dado, dando um valor x;

* Determinar as raízes do polinómio;

* Obter o grau do polinómio;

* Somar 2 polinómios;

* Multiplicar um monómio por um polinómio,

* Multiplicar dois monómios

podem efectuar o download:

codigo fonte

executavel

projecto polinomios -full

Actualizado... dia 6 de Março de 2006 .... nova versao com as dicas dadas!!

Share this post


Link to post
Share on other sites
saramgsilva

mesmo assim, coloco aqui o codigo fonte :D

Actualizado a 6/3/06

Polinomios.cpp

//             Projecto Polinomios

//     Programadores:  Roberto Luttner   
//                     Rui Mendes
//                     Sara Silva
//
//            www.portugal-a-programar.org

// Data da ultima alteracao  : 06/04/06


#include<iostream>
#include<cmath>

using namespace std;

// Class Polinomio para polinomios de grau inferior a 100


class Polinomio{
    private:
          double coef[100];
    public:
       Polinomio(){
         for(int i=0; i<100; i++)
             coef[i]=0.0;
       }     

       Polinomio(double c[100]){
         for(int i=0;i<100; i++)
             coef[i]=c[i];
       }

       virtual int obtem_grau()const{
         int i;

         for(i=99; i>=0; i--){
             if(coef[i]==0.0)
              continue;
             else
              return i; 
          }
       }

       virtual double obtem_coef(int n)const {
         return coef[n];
       }

       virtual void muda_coef(int n, double d){
               coef[n]=d;
       }

       virtual double valor_fx(double x)const {
         double v=0;
         int i;

         for( i=0; i<=obtem_grau();i++){
              v= v + coef[i]*pow(x,i);
         }   

         return v;
       }

       virtual Polinomio derivada()const {
          Polinomio p;

          for(int i=0; i<obtem_grau();i++)
              p.coef[i]=coef[i+1]*(i+1);
          p.coef[obtem_grau()]=0.0;

          return p;
       }

       virtual Polinomio primitiva(double c)const {
          Polinomio p;

          if(obtem_grau()==99)
               cout<<"\tErro de polinomio: grau maior ou igual a 100\n";
          else {
                 Polinomio aux;
                 aux.coef[0]=c;
                 for (int i=1;i<=obtem_grau()+1;i++){
                   aux.coef[i]=coef[i-1]/i;
                 }

                 return aux;
              }
       }

      virtual Polinomio soma_poli(Polinomio o)const {
        Polinomio aux;
        int i;

        if( obtem_grau()<100 && o.obtem_grau()<100 ) {
           for(i=0; i<= 100 ;i++) {
               aux.muda_coef(i, coef[i]+o.coef[i] );
           }

           return aux;
         }
      }

      virtual void tipo()const{
              cout<<" Polinomio ";
      }

      virtual void printGrau()const{
              cout<<"\tO grau do "; tipo(); cout<<" e' "<< obtem_grau() <<"\n";
      }

      virtual void escrevepoli()const {
            cout<<"\t";     
            if(obtem_grau()>0)
              for(int i=obtem_grau(); i>0;i--) {
                  if (coef[i]!=0)
                        cout<<coef[i]<<"x^"<<i<<" + ";
                }

            cout<<coef[0]<<".";
            cout<<"\n";
      }           
};


class Monomio :public Polinomio{
 private:
 public:

      Monomio():Polinomio(){};
      Monomio(double c, int n):Polinomio(){ muda_coef(n, c); };



       //metodo para multiplicar um monomio por 1 monomio
       // resulta outro monomio
       virtual Monomio multiplica(Monomio b) const {
               if ((b.obtem_grau()+obtem_grau())<100) {
                  Monomio aux;
                  aux.muda_coef( (b.obtem_grau()+obtem_grau()) , b.obtem_coef(b.obtem_grau())*obtem_coef(obtem_grau()));
                  return aux;
               } else
                 cout<<"\tErro de polinomio: grau maior ou igual a 100\n";
       }


      // metodo pra multiplicar 1 monomio por um polinomio qq
      // resulta um polinomio
       virtual Polinomio mult_mono(Polinomio b) const {
               if ((b.obtem_grau()+obtem_grau())<100) {
                  Polinomio aux;
                  for (int i=0;i<=b.obtem_grau();i++)
                      aux.muda_coef((i+obtem_grau()), b.obtem_coef(i)*obtem_coef(obtem_grau()));
                  return aux;
               }
               else
                   cout<<"\tErro de polinomio: grau maior ou igual a 100\n";
       }



      // calcular o valor de y=f(x)
      virtual double valor_fx(double x)const {
        return pow( x, obtem_grau() )*obtem_coef( obtem_grau() );
      }

       virtual void tipo()const{
               cout<<"Monomio ";
       }

       virtual void read() {
               double a;
               int n;

               cout<<"\n\tIntroduza o monomio da forma a*x^n.\n Coeficiente a de a*x^n-> ";
               cin>>a;
               cout<<"\n\tGrau n do polinomio-> ";
               cin>>n;
               muda_coef(n, a);
       }

       virtual void escrevepoli()const {   
           cout<<"\tO monomio e':"<<obtem_coef(obtem_grau())<<"*x^"<<obtem_grau()<<".\n";
      }

};



// class de polinomios de 2 grau que e subclass de polinomio

class Poli2grau: public Polinomio{
     private:
     public:
      Poli2grau():Polinomio(){};
      Poli2grau(double c[3]):Polinomio(c){};


      // Calcular as raizes do polinomio de 2 grau
      virtual void raizes(double *a,double *b)const{

         double delta;
            cout<<"\n\n";
            cout<<"\n\t *****************";
            cout<<"\n\t **  Resultado  **";
            cout<<"\n\t *****************\n";
         delta= pow( obtem_coef(1) ,2 ) - 4*obtem_coef(2)*obtem_coef(0);

         if( delta <0 )
         {cout<<"\tPolinomio tem raiz complexa, nao e possivel resolver em R^2\n";}
         else
          if(obtem_coef(2)==0)
           {cout<<"\tFoi detectado um erro... nao e possivel efectuar a divisao...\n ";}
          else
          {
           (*a) = ( -obtem_coef(1) + sqrt(delta) )/(2*obtem_coef(2));
           (*b) = ( -obtem_coef(1) - sqrt(delta) )/(2*obtem_coef(2));

           cout<<"\n\tAs raizes sao: "<<(*a)<<" e "<<(*b)<<"\n";
          }
     }

      // calcular o valor de y=f(x)
      virtual double valor_fx(double x)const {
        return x*x*obtem_coef(2)+x*obtem_coef(1)+obtem_coef(0);
      }


      virtual void tipo()const{
              cout<<"Polinomio de 2o grau";
      }


      // ler um polinomio de 2 grau do ecra
      virtual void read() { 
         double aux;

         cout<<"\n\tPretende manipular polinomios de 2 grau: a*x^2+b*x+x \n Introduza os respectivos valores:";
         cout<<"\n\tValor do coeficiente de maior grau ->";
         cin>>aux; muda_coef(2,aux);
         cout<<"\n\tValor do coeficiente do termo em x ->";
         cin>>aux; muda_coef(1,aux);
         cout<<"\n\tValor do coeficiente independente  ->";
         cin>>aux; muda_coef(0,aux);
         cout<<"\n\tPode continuar a efectuar outras operacoes com este polinomio\n";
      }
};
 

Share this post


Link to post
Share on other sites
saramgsilva

main_polinomio.cpp

Actualizado em 6/3/06  - Peço desculpas mas o programa é mto grande,nao da para colocar o correcto... aki da para ver o codigo, que nao esta completo (nada de mais , 1 menu de apresentação...)  vejam o codigo de fonte que disponibilizo... obrigada!!

//             Projecto Polinomios

//     Programadores:  Roberto Luttner    
//                     Rui Mendes 
//                     Sara Silva
//
//            www.portugal-a-programar.org

// Data da ultima alteracao  : 03/04/06 

#include<iostream>
#include<cmath>
#include "Polinomios.cpp"

using namespace std;

int menu();
void sub_menu_polinomio();
void sub_menu_monomio();
void sub_menu_poli_2();

int main(){
     cout<<"\n\n";    
          cout<<"\n\n\t****************************************\n";
          cout<<"\t* PROGRAMA :  OPERACOES COM POLINOMIOS *\n";
          cout<<"\t****************************************\n";
        // ( ..... ) ;
	  
     
    system("pause");
   system("cls");
    menu();
  
    return 0; 

}//Fim do Main
//#################   MENU PRINCIPAL  ########################
//menu principal, para manipular : ou Polinomios ou monomio ou poli2grau:
int menu() {
    
       int t;
       
      do {

	  cout << "\n\n\n\t        MENU PRINCIPAL \n\n";
	  cout << "\t#################################\n";
	  cout << "\t##                             ##\n";
	  cout << "\t##   Qual a opccao desejada:   ##\n";
	  cout << "\t##                             ##\n";
	  cout << "\t##                             ##\n";
	  cout << "\t##  1 - Polinomios  (n<100)    ##\n";
	  cout << "\t##                             ##\n";
	  cout << "\t##  2 - Monomios               ##\n";
	  cout << "\t##                             ##\n";
	  cout << "\t##  3 - Polinomios de 2o grau  ##\n";
	  cout << "\t##                             ##\n";
	  cout << "\t##  0 - Sair                   ##\n";
	  cout << "\t##                             ##\n";
	  cout << "\t##                             ##\n";
	  cout << "\t#################################\n";
	  cout<<"\n\tOpccao-> ";
	  cin >> t;
system("cls");
    
      
    
       switch (t){

              case 1:
                   sub_menu_polinomio();
                   break;
              case 2:
                   sub_menu_monomio();
                   break;
              case 3:
                   sub_menu_poli_2();
                   break;
              case 0: //sair
                   break;
              default: 
                      cout << "\n\tA opcçao escolhida nao e valida...\n\n";
        }//Fim do switch
        
        }while (t!=0);
    
    return 0;
}

//#################   SUB-MENU POLINOMIO  ########################
void sub_menu_polinomio() {
     int r,i;     
     int n=0;
     double c[100];
     
     cout<<"\n\n\tVamos efectuar operacoes com polinomios de grau <100.\n";
       
     do{
        cout<<"\n\tIntroduza o grau do polinomio ( 0<= Grau <100 ):  \n\t";
        cin>>n;
        if (n<0 || n>=100) //Aqui o grau ou é menor que zero ou maior que 99 e avisa com uma msg de erro
           cout<<"\n\tErro.... O grau do polinomio tem que estar entre 0 e 99...\n";
        
     }while(n<0 || n>=100 ); //Aqui o grau ou é menor que zero ou maior que 99
     
        for(i=0; i<=n;i++){ 
                 cout<<"\n\tIntroduza o coeficiente de grau "<<i<<":\n\t";
                 cin>>c[i];      
        }
     
        for(i=n+1; i<100;i++){ 
                   c[i]=0;
        }
      
       cout<<"\n\tTerminou, ja leu os coeficientes...\n";
                      
     Polinomio g(c);
     system("cls");
     g.escrevepoli();
    
     do{  
       
       cout << "\n\n\t  MENU SECUNDARIO - POLINOMIOS \n\n";   
       cout << "\n\t#################################\n";
       cout << "\t##                             ##\n";
       cout << "\t##   Qual a opcçao desejada:   ##\n";
       cout << "\t##                             ##\n";
       cout << "\t##  1 - Primitiva              ##\n";
       cout << "\t##                             ##\n";
       cout << "\t##  2 - Derivada               ##\n";
       cout << "\t##                             ##\n";
       cout << "\t##  3 - Calcular f(x)          ##\n";
       cout << "\t##                             ##\n";
   cout << "\t##  4 - Obter o grau           ##\n";
   cout << "\t##                             ##\n";
   cout << "\t##  5 - Somar 2 polinomios     ##\n";
       cout << "\t##                             ##\n";   
       cout << "\t##  0 - Sair                   ##\n";
       cout << "\t##                             ##\n";
       cout << "\t#################################\n\t\t";
       cout<<"\n\tOpccao-> ";
       cin >> r;
    system("cls");
    
       switch (r){
              
              case 1:{ 
			  
			  Polinomio prim;
			  double C;
			  
			  cout<<"\n\tIntroduza o valor constante C: \n\t";
			  cin>>C;
			  
			  prim=g.primitiva(C);
                                  system("cls");
			  prim.escrevepoli();
                  
			  break;
                   }

              case 2:{ 
			  
			  Polinomio der;

                                  der=g.derivada();
                                  system("cls");
			  der.escrevepoli();
			  break;
                   }

              case 3:{ 
			  
			  double y,x;
			  
			  cout<<"\n\tEscreva o valor de x: \n\t";
			  cin>>x;
			  y=g.valor_fx(x);
                                  system("cls");
			  cout<<"\n\tO valor de f("<<x<<")="<<y<<"\n";
			  break;
                   }

		  case 4:{ 
			  system("cls");
			  g.printGrau();

			  break;
                   }
                   
              case 5:{ 
                   
			    Polinomio soma;
			    
                    cout<<"\n\tPara poder somar 2 polinomios";
                    cout<<"\n\tterá que introduzir um polinomio...\n";
                    
                    int n=0,i;
                    double c[100];
     
                    cout<<"\n\tVamos efectuar operacoes com polinomios de grau <100, que ira introduzir...\n";
  
                    do{
                       cout<<"\n\tIntroduza o grau do polinomio ( 0<= Grau <100 )  \n";
                       cin>>n;
                       if (n<0 || n>=100) //Aqui o grau ou é menor que zero ou maior que 99 e avisa com uma msg de erro
                          cout<<"\n\tErro.... O grau do polinomio tem que estar entre 0 e 99...\n";
                    }while(n<0 || n>=100 );
     
                    for(i=0; i<=n;i++){ 
                             cout<<"\n\tIntroduza o coeficiente de grau "<<i<<":\n\t";
                             cin>>c[i];      
                    }
     
                    for(i=n+1; i<100;i++){ 
                               c[i]=0;  
                    }
      
                    cout<<"\n\tTerminou, ja leu os coeficientes...\n";
                      
                    Polinomio q(c);
     
                    cout<<"\n\tPara o ajudar a recordar os polinomios que introduziu, vamos escreve-los\n";
                    cout<<"\tO primeiro polinomio introduzido\n";
                    g.escrevepoli();
                    cout<<"\tO segundo polinomio introduzido\n";
                    q.escrevepoli();
                    cout<<"\n\tFinalmente vamos efecutar o que pretendia\n";
                    cout<<"\tSoma dos polinomios anteriores, que resulta num outro polinomio: ";
                    soma=g.soma_poli(q);
                   system("cls");
                    soma.escrevepoli();
                    break;			 
                 
                   }
              case 0: //sair                 
                   break;

              default: 
                      cout << "\n\tA opcçao escolhida nao e valida...";
        }//Fim do switch 
        
        } while(r!=0);
} 
//#################   SUB-MENU MONOMIO  ##########################
void sub_menu_monomio() {

int t;
Monomio p;

      cout<<"\n\tVamos efectuar operacoes com o monomio que ira introduzir...\n";
      
      p.read();
     system("cls");
      p.escrevepoli();
       
      do { 

	  cout << "\n\n\t   MENU SECUNDARIO - MONOMIOS \n\n";
	  cout << "\n\t#################################\n";
	  cout << "\t##                             ##\n";
	  cout << "\t##   Qual a opccao desejada:   ##\n";
	  cout << "\t##                             ##\n";
	  cout << "\t##                             ##\n";
	  cout << "\t##  1 - Primitiva              ##\n";
	  cout << "\t##                             ##\n";
	  cout << "\t##  2 - Derivada               ##\n";
	  cout << "\t##                             ##\n";
	  cout << "\t##  3 - Calcular f(x)          ##\n";
	  cout << "\t##                             ##\n";
	  cout << "\t##  4 - Obter o grau           ##\n";
	  cout << "\t##                             ##\n";
          cout << "\t##  5 - Somar 2 monomios       ##\n";
    	  cout << "\t##                             ##\n";
          cout << "\t##  6 - Multiplicação de dois  ##\n";
    	  cout << "\t##      Monomios               ##\n";
    	  cout << "\t##                             ##\n";
          cout << "\t##  7- Multiplicação de um     ##\n";
          cout << "\t##  polinomio por um monomio   ##\n";
          cout << "\t##                             ##\n";
          cout << "\t##  0 - Sair                   ##\n";
	  cout << "\t##                             ##\n";
	  cout << "\t##                             ##\n";
	  cout << "\t#################################\n\t\t";
	  cout<<"\n\tOpccao-> ";
	  cin >> t;
                 system("cls");
    
       switch (t){

              case 1:{ 
			  
			  Polinomio prim;
			  double C;
			  
			  cout<<"\n\tIntroduza o valor constante C:\n";
			  cin>>C;
			  
			  prim=p.primitiva(C);
                                  system("cls");
			  prim.escrevepoli();
                  
			  break;
                   }

              case 2:{ 
			  
			  Polinomio der;
                  
			  der=p.derivada();
                                 system("cls");
			  der.escrevepoli();
                  
			  break;
                   }

              case 3:{ 
			  
			  double y,x;
			  
			  cout<<"\n\tEscreva o valor de x:\n\t";
			  cin>>x;
			  
			  y=p.valor_fx(x);
			  system("cls");
			  cout<<"\n\tO valor de f("<<x<<")="<<y<<"\n";
			  
			  break;
                   }

		  case 4:{ 
			  system("cls");
			  p.printGrau();
			  
			  break;
                   
                   }
              case 5:{ 
			    Monomio br;
                    Polinomio soma;
                    cout<<"\n\tPara poder somar 2 polinomios terá que introduzir um segundo polinomio...\n";
                    br.read();
                    cout<<"\tPara o ajudar a recordar os polinomios que introduziu, vamos escreve-los.\n";
                    cout<<"\tO primeiro monomio introduzido:\n";
                    p.escrevepoli();
                    cout<<"\tO segundo monomio introduzido:\n";
                    br.escrevepoli();
                    cout<<"\n\tFinalmente vamos efecutar o que pretendia...\n";
                    cout<<"\tSoma dos polinomios anteriores, que resulta num outro polinomio: \n";
                    soma=p.soma_poli(br);
                   system("cls");
                    soma.escrevepoli();
                    break;			 
                 
                   }
              case 6:{ 
        		    Monomio o;
                    Monomio multip;
                    cout<<"\n\tPara poder multiplicar 2 monomios terá que introduzir um segundo monomio...\n";
                    o.read();
                    cout<<"\tPara o ajudar a recordar os monomios que introduziu, vamos escreve-los.\n";
                    cout<<"\tO primeiro monomio introduzido:\n";
                    p.escrevepoli();
                    cout<<"\tO segundo monomio introduzido:\n";
                    o.escrevepoli();
                    cout<<"\n\tFinalmente vamos efecutar o que pretendia...\n";
                    cout<<"\tMutiplicacao do monomios anteriores, que resulta num outro monomio: \n";
                    multip=p.multiplica(o);
                    multip.escrevepoli();
                    break;			 
                               
                   }
           case 7:{ 
                    Polinomio  multip;
                    cout<<"\n\tPara poder multiplicar um monomio por um polinomio.";
                    cout<<"\n\tE terá que introduzir um polinomio...\n";
                   
                    int n=0,i;
                    double c[100];
     
                    cout<<"\tVamos efectuar operacoes com polinomios de grau <100, que ira introduzir...\n";
  
                    do{
                     cout<<"\tIntroduza o grau do polinomio ( 0<= Grau <100 ):  \n\t";
                     cin>>n;
                     if (n<0 || n>=100) //Aqui o grau ou é menor que zero ou maior que 99 e avisa com uma msg de erro
                          cout<<"\n\tErro.... O grau do polinomio tem que estar entre 0 e 99...\n";
                    }while(n<0 || n>=100 );
     
                    for(i=0; i<=n;i++)
                    { cout<<"\tIntroduza o coeficiente de grau "<<i<<":\n";
                      cin>>c[i];      
                    }
     
                    for(i=n+1; i<100;i++)
                    { c[i]=0;      
                    }
      
                    cout<<"\n\tTerminou, ja leu os coeficientes...\n";
                      
     
                    Polinomio s(c);
     
                                      
                    cout<<"\n\tPara o ajudar a recordar os polinomios que introduziu, vamos escreve-los\n";
                    cout<<"\tO primeiro polinomio ( monomio ) introduzido:\n";
                    p.escrevepoli();
                    cout<<"\tO segundo polinomio introduzido:\n";
                    s.escrevepoli();
                    cout<<"\n\tFinalmente vamos efecutar o que pretendia\n";
                    cout<<"\tMultiplicacao do polinomio por um monomio anterior, que resulta num outro polinomio: \n\t";
                    multip=p.mult_mono(s);
                    system("cls");
                    multip.escrevepoli();
                    break;			 
                               
                   }
              case 0: //sair
			  
			  break;

              default: 
			  cout << "\n\tA opcçao escolhida nao e valida...\n";
   }//Fim do switch

  }
  while (t!=0);   
}
     
//#############   SUB-MENU POLINOMIOS DE 2o GRAU  ################
void sub_menu_poli_2() {

     int r;
     Poli2grau p;

 p.read();
         system("cls");
 p.escrevepoli();
     
     do {

	 cout << "\n\n  MENU SECUNDARIO - POLINOMIOS DE 2o GRAU \n\n";
	 cout << "\n\t###########################################\n";
	 cout << "\t##                                       ##\n";
	 cout << "\t##   Qual a opccao desejada:             ##\n";
	 cout << "\t##                                       ##\n";
	 cout << "\t##                                       ##\n";
	 cout << "\t##  1 - Primitiva                        ##\n";
	 cout << "\t##                                       ##\n";
	 cout << "\t##  2 - Derivada                         ##\n";
	 cout << "\t##                                       ##\n";
	 cout << "\t##  3 - Calcular f(x)                    ##\n";
	 cout << "\t##                                       ##\n";
	 cout << "\t##  4 - Calcular as raizes               ##\n";
	 cout << "\t##                                       ##\n";
	 cout << "\t##  5 - Obter o grau                     ##\n";
	 cout << "\t##                                       ##\n";
         cout << "\t##  6 - Somar 2 polinomios de 2o grau    ##\n";
    	 cout << "\t##                                       ##\n";
         cout << "\t##  0 - Sair                             ##\n";
	 cout << "\t##                                       ##\n";
	 cout << "\t##                                       ##\n";
	 cout << "\t###########################################\n\t\t";
	 cout<<"\n\tOpccao-> ";
	 cin >> r;
               system("cls");
    
       switch (r){

              case 1:{ 

			  Polinomio prim;
			  double C;
			  
			  cout<<"\n\tIntroduza o valor constante C:\n";
			  cin>>C;
			  
			  prim=p.primitiva(C);
			  system("cls");
                                    prim.escrevepoli();
			  
			  break;
                   }

              case 2:{ 

			  Polinomio der;
			  
			  der=p.derivada();
                                  system("cls");
			  der.escrevepoli();
			  
			  break;
                   }

              case 3:{ 
			  
			  double y,x;
			  
			  cout<<"\n\tEscreva o valor de x: \n\t";
			  cin>>x;
			  
			  y=p.valor_fx(x);
                                  system("cls");
			  cout<<"\n\tO valor de f("<<x<<")="<<y<<"\n";
			  
			  break;
                   }

             case 4:{ 

			 double r1,r2;
			 system("cls");
			 p.raizes(&r1, &r2);


			 break;          
                   }

		 case 5:{ 
			 system("cls");
			 p.printGrau();

			 break;
                   
                   }
             
              case 6:{ 
			    Poli2grau q;
                    Polinomio soma;
                    cout<<"\n\tPara poder somar 2 polinomios terá que introduzir um segundo polinomio...\n";
                    q.read();
                    cout<<"\tPara o ajudar a recordar os polinomios que introduziu, vamos escreve-los.\n";
                    cout<<"\tO primeiro polinomio introduzido:\n";
                    p.escrevepoli();
                    cout<<"\tO segundo polinomio introduzido:\n";
                    q.escrevepoli();
                    cout<<"\n\tFinalmente vamos efecutar o que pretendia\n";
                    cout<<"\tSoma dos polinomios anteriores, que resulta num outro polinomio: \n\t";
                    soma=p.soma_poli(q);
                    
                    soma.escrevepoli();
                    break;			 
                 
                   }      
              case 0: //sair
			  
			 break;

              default: 
                      cout << "\n\tA opcçao escolhida nao e valida...\n";
   }//Fim do switch
 } while(r!=0);
}

Share this post


Link to post
Share on other sites
saramgsilva

Espero que gostem...e que vos seja util...

p.s.: voces como sao intelegente nao colocam letras em vez de numeros pois nao? ok...senao o programava entra em ciclo infinito... 😳

eheh  ;)

Nota:podem ver uma versao de polinomios de grau 2: calculo de f(x) e calculo das raizes em ... tofas.com.sapo.pt sendo uma versao simples feita em php  :)

Share this post


Link to post
Share on other sites
deathseeker25

Sim, o programa está muito bem feito. Gostei de ver. Tive pena de mim mesmo quando escrevi que o grau do polinómio era de 99.... :cheesygrin: Tive de colocar 99 coeficientes...

Bom  trabalho, tofas. :)

Share this post


Link to post
Share on other sites
brink@ero

Bom programa :)

Queria dar 3 sugestões para a próxima versão:

1.º puramente estético:

          cout << "\t##  6 - Multiplicação de dois       ##\n";
    	  cout << "\t##      Monomios                         ##\n";
    	  cout << "\t##                                               ##\n";
          cout << "\t##  7- Multiplicação de um          ##\n";
          cout << "\t##  polinomio por um monomio   ##\n";

É que "çã" na minha consola aparece com caracteres esquisitos e o n.º 7 não é coerente com o 6  :bored:

          cout << "\t##  6 - Multiplicacao de dois       ##\n";
    	  cout << "\t##       Monomios                        ##\n";
    	  cout << "\t##                                               ##\n";
          cout << "\t##  7 - Multiplicacao de um         ##\n";
          cout << "\t##       polinomio por um             ##\n";
          cout << "\t##       monomio                          ##\n";

O segundo é que podias tornar o programa para qualquer polinómio:

em vez de:

           double coef[100];

podias por um apontador:

           double *coef;

Assim se alguem der na tola de querer um polinómio de grau 1000, não há restrições.

O bom disto torna o teu programa mais robusto, eficaz e abstracto.

O terceiro é de interface, tambem puramente estético:

depois de usar muito o programa fica-se com a consola sobrecarregada de dados, por isso sugeria que depois do último cin>>, uma limpeza no ecran

           system("cls");

Share this post


Link to post
Share on other sites
saramgsilva

Bom programa :)

Queria dar 3 sugestões para a próxima versão:

1.º puramente estético:

          cout << "\t##  6 - Multiplicação de dois       ##\n";
    	  cout << "\t##      Monomios                         ##\n";
    	  cout << "\t##                                               ##\n";
          cout << "\t##  7- Multiplicação de um          ##\n";
          cout << "\t##  polinomio por um monomio   ##\n";

É que "çã" na minha consola aparece com caracteres esquisitos e o n.º 7 não é coerente com o 6  :bored:

          cout << "\t##  6 - Multiplicacao de dois       ##\n";
    	  cout << "\t##       Monomios                        ##\n";
    	  cout << "\t##                                               ##\n";
          cout << "\t##  7 - Multiplicacao de um         ##\n";
          cout << "\t##       polinomio por um             ##\n";
          cout << "\t##       monomio                          ##\n";

eu sei disto...{ ç ã õ á é} escapou... :wallbash:  nao percebi a parte do nº7 nao é coerente com o 6?? nao percebi...  :down:

estas a falar que multiplicar um polinomio por um monomio é a mesma coisas que 1 monomio por um monomio... bem eu para 6 podia usar o metodo que uso par o 7, mas imagina que tenho os monomios x^26 e x^20 ao multiplicar pelo metodo que uso em 6, tenho logo x^(26+20) e pelo metodo que uso em 7, vou percorrer todos os coeficientes do polinomio, mesmo sendo zero... percebes? é 1 questao de rapidez a efectuar o calculo...ve o codigo dessa parte ... :D

O segundo é que podias tornar o programa para qualquer polinómio:

em vez de:

           double coef[100];

podias por um apontador:

           double *coef;

Assim se alguem der na tola de querer um polinómio de grau 1000, não há restrições.

O bom disto torna o teu programa mais robusto, eficaz e abstracto.

sim é uma ideia, e claro possivel de ser implementada.... e o programa ficava mto melhor...mas ao mesmo tempo, nao faz sentido...pois ninguem usa assim polinomios com 1 grau tao elevado...  :P mas quem sabe...tv o faça...  :)

O terceiro é de interface, tambem puramente estético:

depois de usar muito o programa fica-se com a consola sobrecarregada de dados, por isso sugeria que depois do último cin>>, uma limpeza no ecran

           system("cls");

e nao é preciso colocar nenhuma biblioteca???

e a seguir ao ultimo cin>> ... qual? o que é para ti o ultimo cin>>?  😳

Share this post


Link to post
Share on other sites
brink@ero

Sobre o n.º 7, eu queria dizer nos espaços:

"(...)6 - Mult(...)" e no "(...)7- Mult(...)" falta 1 espaço entre entre o 7 e o -.

E depois na nova linha o alinhamento da palavra "polinomino" da opcção 7 não está alinhado com a palavra "Monomios" da opcção 6.

Como tinha referido, são pormenores estéticos.

e nao é preciso colocar nenhuma biblioteca???

e a seguir ao ultimo cin>> ... qual? o que é para ti o ultimo cin>>?

Ai aii, tu já tens no código:

system("pause");

A funcção é a mesma, o argumento é que é diferente.

Sobre o local a colocar a instrucção seria depois de dar a última informação (input) e antes dos resultados (output).

Por exemplo:

Estás no menu principal

Escolho a opcção 1, coloco o grau e os coeficientes.

Depois de colocar todos os inputs (colocar o último coeficiente), limpavas o ecran.

De seguida escrevias o resultado e o novo menu.

Assim para quem tem o MS-DOS maximizado não vê os vários menus já impressos com as várias opcções já escolhidas.

Um ambiente em que só apresente o último resultado e o menu com as opções, dá uma outra imagem ao programa (mais profissional  :) ).

E se prentederes, tendo uma apresentação simples (poucas linhas), depois do "system("cls");" chamavas uma função de apresentação com os print que tem a função main.

Assim o ambiente ficava sempre assim:

                    ###################

                            apresentação

                    ###################

resultado:

                    4*x^43...

                      MENU ...

                    ###################

                            as opções do menu

                    ###################

opccao ->

PS: No menu secundário - polinómios -> corrige no cout "opcçao" para "opccao"

Share this post


Link to post
Share on other sites
saramgsilva

é normal que nao saibas  o que é um polinomio, em breve na escola vais aprender..

ve aqui a definição

é normal que nao percebas muito bem o que é mas...

( nota sabes o que é uma equação?? nao sabes...acho que sim...então tipo x+2x+1=4 posso dizer que é o polinomio de grau 1 3x+1-4=0 <=> f(x)=3x-3 e f(x)=0  neste caso estou a calcular uma raizz do polinomio... )

um pouco complexo para a tua idade... espero que tenha ajudado...  😳

Share this post


Link to post
Share on other sites
UnKnowN

é normal que nao saibas  o que é um polinomio, em breve na escola vais aprender..

ve aqui a definição

é normal que nao percebas muito bem o que é mas...

( nota sabes o que é uma equação?? nao sabes...acho que sim...então tipo x+2x+1=4 posso dizer que é o polinomio de grau 1 3x+1-4=0 <=> f(x)=3x-3 e f(x)=0 neste caso estou a calcular uma raizz do polinomio... )

um pouco complexo para a tua idade... espero que tenha ajudado...  😳

Muito Boa explicaçao eu nao sabia o que era e fikei a perceber :)

Share this post


Link to post
Share on other sites
QuickFire

lol :P eu polinómios acho que nunca trabalhei com nenhum superior a 3 ou 4 :) por isso até 100 é muita fruta :)

Share this post


Link to post
Share on other sites
saramgsilva

venho anunciar que esta disponivel a nova versao dos polinomios, com as dicas dadas pelo brinkaero

alterei os posts iniciais...mas o ficheiro main_polinomios.cpp é muito grande e a base de dados nao suporta td,entao tive que retirar algumas coisas, tipo retirei o menu inicial de apresentação...por isso peço que vejam o codigo fonte que disponibilizo!!  :)

obrigada!

As dicas foram mto boas!! gostei de usar  o systema("cls");  :P   :)

Share this post


Link to post
Share on other sites
house

Vê-se logo quem é estuda na UC :)

Agora fora de brincadeiras... Grande programa mesmo :D

Os meus parabens aos autores! Está de facto muito bom.

Share this post


Link to post
Share on other sites
saramgsilva

Vê-se logo quem é estuda na UC :D

Agora fora de brincadeiras... Grande programa mesmo :)

Os meus parabens aos autores! Está de facto muito bom.

Obrigada!! :D o programa nem foi dificil de fazer...é so preciso ter os conhecimentos...e ai ta..a nossa obra de arte :) por acaso adoro este projecto!

que gostava de implementar em php, tambem a usar classes...quando eu souber +

:)

Share this post


Link to post
Share on other sites
saramgsilva

O segundo é que podias tornar o programa para qualquer polinómio:

em vez de:

           double coef[100];

podias por um apontador:

           double *coef;

Assim se alguem der na tola de querer um polinómio de grau 1000, não há restrições.

O bom disto torna o teu programa mais robusto, eficaz e abstracto.

bem existe outra coisa, simples de implementar, penso eu pelo que vi...que é usar o std::vector ve isto

e assim terei 1 programa para 1 grau infinito...

e nao preciso de andar com ponteiros...ja estam implementados implicitamente... bem ver se faço isso para breve...  :)

Share this post


Link to post
Share on other sites
brink@ero

O que eu queria dizer é tu utilizares memória dinâmica.

na classe:

double *coef;

e depois de saberes o grau:

coef=new double(grau);

e por fim no destruidor:

delete [] coef;

e nada mais... a não ser apagares as restrições no grau (os ifs...).

Share this post


Link to post
Share on other sites
saramgsilva

O que eu queria dizer é tu utilizares memória dinâmica.

na classe:

double *coef;

e depois de saberes o grau:

coef=new double(grau);

e por fim no destruidor:

delete [] coef;

e nada mais... a não ser apagares as restrições no grau (os ifs...).

mas eu ao implementar o metodo vector, é  generico... e tb funciona +- no mesmo sentido... eu percebi a tua ideia...  :)

Share this post


Link to post
Share on other sites
TheDark

boa... madrugada (credo, já são estas horas??)

sei que já venho um bocado atrasado, mas já agora ficam algumas sugestões para optimização

em polinomios.cpp:

linha 34

        virtual int obtem_grau()const{ 
          int i;
          
          for(i=99; i>=0; i--){
              if(coef[ i ]==0.0)
               continue;
              else
               return i;  
           } 
        }

porquê o uso do continue? e se por um acaso qualquer o programa nunca entrasse no else? ou seja, se ocorresse um erro e coef[ i ] fosse sempre igual a 0? nunca retornavas!

o código seria mais simples e robusto se usasses:

virtual int obtem_grau()const{ 
	int i=99;
	while (coef[i--]==0.0);
	return i;
}

outro problema de retorno na linha 74 do mesmo ficheiro:

        virtual Polinomio primitiva(double c)const {
           Polinomio p;
       
           if(obtem_grau()==99)
                cout<<"\tErro de polinomio: grau maior ou igual a 100\n";
           else {
                  Polinomio aux;
                  aux.coef[0]=c;
                  for (int i=1;i<=obtem_grau()+1;i++){
                    aux.coef[i]=coef[i-1]/i;
                  }
                
                  return aux;
               }
        }

quando o obtem_grau() retorna 99, onde é que é feito o retorno? Coisa engraçada é que o Visual Studio 2005 avisa que este troço de código nunca será atingido, sendo essa a explicação para nunca ter dado problemas. Penso que te esqueceste do Polinomio p do inicio da função quando depois declaraste o aux mais abaixo. Outra coisa, e se o grau do polinómio for menor que 0?  Ora bem...

        virtual Polinomio primitiva(double c)const {

		if(obtem_grau()==99 || obtem_grau() == 0) {
			cout<<"\tErro de polinomio: grau maior ou igual a 100 ou menor que 0\n";
			return (Polinomio)NULL;
		}

		Polinomio aux;
		aux.coef[0]=c;

		for (int i=1; i<=obtem_grau()+1; i++)
			aux.coef[i]=coef[i-1]/i;

		return aux;
	}

com estas alterações eliminas o problema mais visível (para mim) : a função agora retorna sempre (retornando NULL caso o grau do polinómio esteja fora do dominio pretendido ( [0, 100[) )

Mesmo com o compilador a dizer que o código nunca será executado :P

Há muitas outras maneiras de optimizares o código - nomeadamente criar um atributo grau, que é preenchido unicamente quando se define o grau do polinómio; isto iria alterar a função obtem_grau() que simplesmente iria retornar uma variável, o que iria poupar muito código gerado nesta função. Mas isso são outras histórias e se calhar nem pretendes que o código gerado seja particularmente rápido, principalmente com os computadores de hoje. Mas acredita que numa máquina um pouco mais antiga ias notar diferenças.

Bem, já é muito tarde, e isto é o meu 1º post. Se quiseres mais esclarecimentos, avisa ;)


Desaparecido.

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.