/ PROG0613.CPP - Suma de polinomios dependientes de dos variables
//
#include <iostream.h>                                                                    
#include "cpolinom.h" // clases CTermino y CPolinomio
 
CTermino *IntroducirTermino( void );
 
void main() // función principal
{
  CPolinomio PolinomioA, PolinomioB, PolinomioR;
  CTermino *ptx; // puntero a un término
 
  cout << "Términos del polinomio A\n"
       << "(para finalizar introduzca 0 para el\n"
       << "coeficiente y para los exponentes):\n\n";
  ptx = IntroducirTermino();
  while ( ptx )
  {
    PolinomioA.AsignarTermino( ptx );
    ptx = IntroducirTermino();
  }
 
  cout << "Términos del polinomio B\n"
       << "(para finalizar introduzca 0 para el\n"
       << "coeficiente y para los exponentes):\n\n";
  ptx = IntroducirTermino();
  while ( ptx )
  {
    PolinomioB.AsignarTermino( ptx );
    ptx = IntroducirTermino();
  }
 
  PolinomioR = PolinomioA + PolinomioB;
 
  cout << "\nPolinomio A: "; cout << PolinomioA;
  cout << "\nPolinomio B: "; cout << PolinomioB;
  cout << "\nPolinomio R: "; cout << PolinomioR
       << " = " << PolinomioR(1, 1);
  cout << endl;
 
  double v = PolinomioR; // valor del polinomio para x = 1 e y = 1
  cout << "Para x = 1 " << " el valor del polinomio es: "
       << v << endl;
}
 
CTermino *IntroducirTermino()
{
  CTermino *ptx = NULL;
  float coef;
  int expx, expy;                    
  cout << "Introduce coeficiente:    "; cin >> coef;
  cout << "Introduce exponente en X: "; cin >> expx;
  cout << "Introduce exponente en Y: "; cin >> expy;
  cout << endl;
  if ( !coef && !expx && !expy ) return NULL;
 
  ptx = new CTermino( coef, expx, expy );
  return ptx;
}
 

// CPOLINOM.H - Declaración de las clases CTermino y CPolinomio
//
#if  !defined( _CPolinom_H_ )
#define _CPolinom_H_
 
#include <stdlib.h>
/////////////////////////////////////////////////////////////////
// Clase para manipular un término de un polinomio cualquiera.
class CTermino
{
	protected: 
    float Coeficiente; // coeficiente
    int ExponenteDeX;  // exponente de x
    int ExponenteDeY;  // exponente de y
 
	public:
    CTermino( float coef = 0.0, int expx = 1, int expy = 1 ) :
      Coeficiente(coef), ExponenteDeX(expx), ExponenteDeY(expy) {}
    float ObtenerCoeficiente() { return Coeficiente; }
    int ObtenerExponenteDeX() const { return ExponenteDeX; }
    int ObtenerExponenteDeY() const { return ExponenteDeY; }
    void VisualizarTermino() const;
};                        
//////////////////////////////////////////////////////////////////
 
//////////////////////////////////////////////////////////////////
// Clase para manipular ecuaciones algebraicas o polinómicas
// dependientes de dos variables.	
class CPolinomio
{
  friend ostream &operator<<( ostream &, const CPolinomio & );
  private:
    int NroTerminosMax;   // número máximo de términos
    int NroTerminosAct;   // número de términos que hay actualmente
    CTermino **ppTermino; // array de punteros
 
    void copiar( CTermino *&p, CTermino *&q );
 
  public:
    CPolinomio(); // constructor
    CPolinomio(const CPolinomio &); // constructor copia
    ~CPolinomio(); // destructor
 
    CPolinomio operator=(const CPolinomio &); // operador =
    int ObtenerNroTerminosAct() { return NroTerminosAct; }
    void AsignarTermino( CTermino *pterm );
    CPolinomio operator+( CPolinomio & ); // operador +
    double operator()( double x = 1, double y = 1 ); // operador ()
    operator double(); // operador de conversión
    void ErrorMem( void )
    {
      cerr << "Insuficiente memoria\n";
      exit( -1 );
    }
};
//////////////////////////////////////////////////////////////////	
 
#endif // _CPolinom_H_

// CPOLINOM.CPP - Implementación de las clases CTermino
//                y CPolinomio
//
#include <iostream.h>                                                                    
#include <math.h>           
#include <string.h>
#include <stdlib.h>
#include "cpolinom.h" // clases CTermino y CPolinomio
 
/////////////////////////////////////////////////////////////////
// Visualizar un término
void CTermino::VisualizarTermino() const
{
  cout << ((Coeficiente < 0) ? " - " : " + ")
       << fabs(Coeficiente);
  if ( ExponenteDeX ) cout << "x^" << ExponenteDeX;
  if ( ExponenteDeY ) cout << "y^" << ExponenteDeY;
}
/////////////////////////////////////////////////////////////////
 
/////////////////////////////////////////////////////////////////
// Constructor
CPolinomio::CPolinomio()
{
  NroTerminosMax = 10;
  NroTerminosAct = 0;
  // Reservamos inicialmente espacio para NroTerminosMax términos
  ppTermino = new CTermino *[ NroTerminosMax ];
  if ( ppTermino == NULL ) ErrorMem();
  for ( int i = 0; i < NroTerminosMax; i++ )
    ppTermino[i] = NULL;
}
 
// Destructor
CPolinomio::~CPolinomio()
{
  // Liberar la memoria ocupada por el polinomio
  for ( int i = 0; i < NroTerminosAct; i++ )
    delete ppTermino[i];
  delete [] ppTermino;
}
 
// Copiar un termino del polinomio en otro
void CPolinomio::copiar( CTermino *&p, CTermino *&q )
{
  p = (CTermino *) new CTermino( q->ObtenerCoeficiente(),
                                 q->ObtenerExponenteDeX(),
                                 q->ObtenerExponenteDeY());
  if ( p == NULL ) ErrorMem();
}
 
// Constructor copia
CPolinomio::CPolinomio(const CPolinomio &pol)
{
  NroTerminosMax = pol.NroTerminosMax;
  NroTerminosAct = pol.NroTerminosAct;
  ppTermino = new CTermino *[ NroTerminosMax ];
  if ( ppTermino == NULL ) ErrorMem();
  for ( int i = 0; i < NroTerminosMax; i++ )
    ppTermino[i] = NULL;
  for ( i = 0; i < NroTerminosAct; i++ )
    copiar( ppTermino[i], pol.ppTermino[i] );
}
 
// Operador de asignación
CPolinomio CPolinomio::operator=(const CPolinomio &pol)
{
  // Liberar la memoria del polinomio destino. Este orden es
  // fundamental porque el origen puede tener diferente número de
  // términos. 
  for ( int i = 0; i < NroTerminosAct; i++ )
    delete ppTermino[i];
  delete [] ppTermino;
  // Copiar el origen en el nuevo destino
  NroTerminosMax = pol.NroTerminosMax;
  NroTerminosAct = pol.NroTerminosAct;
  ppTermino = new CTermino *[ NroTerminosMax ];
  if ( ppTermino == NULL ) ErrorMem();
  for ( i = 0; i < NroTerminosMax; i++ )
    ppTermino[i] = NULL;
  for ( i = 0; i < NroTerminosAct; i++ )
    copiar( ppTermino[i], pol.ppTermino[i] );
  return *this;
}
 
// Asigna un término al polinomio colocándolo en orden ascendente
// de los exponentes de x y de y (expx*100+expy). Si no hay espacio
// para el nuevo término se incrementa el tamaño del polinomio en
// dos términos.
void CPolinomio::AsignarTermino( CTermino *pterm )
{
  if ( pterm->ObtenerCoeficiente() == 0 )
  {
    delete pterm; // liberar la memoria del término no insertado
    return;
  }
  if ( abs(pterm->ObtenerExponenteDeX()) > 99 ||
       abs(pterm->ObtenerExponenteDeY()) > 99 )
  {
    cerr << "-99 <= exp <= 99" << endl;
    delete pterm; // liberar la memoria del término no insertado
    return;
  }
 
  if ( NroTerminosAct == NroTerminosMax ) 
  {
    // Incrementar el array en 2 elementos
    CTermino **ppTemp = new CTermino *[ NroTerminosMax + 2 ];
    if ( ppTemp == NULL ) ErrorMem();
    for ( int i = 0; i < NroTerminosMax + 2; i++ )
      ppTemp[i] = NULL;
    for ( i = 0; i < NroTerminosAct; i++ )
      ppTemp[i] = ppTermino[i];
    delete [] ppTermino;
    ppTermino = ppTemp;
    NroTerminosMax += 2;
  }
 
  // Insertar un nuevo término en orden ascendente de los exps.
  int i = NroTerminosAct - 1;
  int expXT = pterm->ObtenerExponenteDeX();
  int expYT = pterm->ObtenerExponenteDeY();
  while ( i >= 0 && (expXT * 100 + expYT <
                     ppTermino[i]->ObtenerExponenteDeX() * 100 + 
                     ppTermino[i]->ObtenerExponenteDeY()) )
  {
    ppTermino[i+1] = ppTermino[i];
    i--;
  }
  ppTermino[i+1] = pterm;
  NroTerminosAct++;
}
 
// Sumar dos polinomios. Sobrecarga del operador +.
CPolinomio CPolinomio::operator+(  CPolinomio &polB )
{
  int ipa = 0, ipb = 0;
  int na = NroTerminosAct, nb = polB.NroTerminosAct;
  float coefA, coefB;
  int expXA, expYA, expXB, expYB;
  CPolinomio polR;
 
  // Sumar polA con polB
  while ( ipa < na && ipb < nb )
  {
    coefA = ppTermino[ipa]->ObtenerCoeficiente();
    expXA = ppTermino[ipa]->ObtenerExponenteDeX();
    expYA = ppTermino[ipa]->ObtenerExponenteDeY();
    coefB = polB.ppTermino[ipb]->ObtenerCoeficiente();
    expXB = polB.ppTermino[ipb]->ObtenerExponenteDeX();
    expYB = polB.ppTermino[ipb]->ObtenerExponenteDeY();
    if ( expXA == expXB && expYA == expYB )
    {
      polR.AsignarTermino(
                   new CTermino(coefA + coefB, expXA, expYA) );
      ipa++, ipb++;
    }
    else if ( expXA * 100 + expYA < expXB * 100 + expYB )
    {
      polR.AsignarTermino( new CTermino(coefA, expXA, expYA) );
      ipa++;
    }
    else
    {
      polR.AsignarTermino( new CTermino(coefB, expXB, expYB) );
      ipb++;
    }
  }
 
  // Términos restantes en el polA
  while ( ipa < na )
  {
    coefA = ppTermino[ipa]->ObtenerCoeficiente();
    expXA = ppTermino[ipa]->ObtenerExponenteDeX();
    expYA = ppTermino[ipa]->ObtenerExponenteDeY();
    polR.AsignarTermino( new CTermino(coefA, expXA, expYA) );
    ipa++;
  }
  // Términos restantes en el polB
  while ( ipb < nb )
  {
    coefB = polB.ppTermino[ipb]->ObtenerCoeficiente();
    expXB = polB.ppTermino[ipb]->ObtenerExponenteDeX();
    expYB = polB.ppTermino[ipb]->ObtenerExponenteDeY();
    polR.AsignarTermino( new CTermino(coefB, expXB, expYB) );
    ipb++;
  }
  return polR;
}
 
// Visualizar los términos de un polinomio.
// Operador de inserción.
ostream &operator<<( ostream &os, const CPolinomio &polX )
{
  int i = polX.NroTerminosAct;
 
  while ( i-- )
    if ( polX.ppTermino[i]->ObtenerCoeficiente() )
      polX.ppTermino[i]->VisualizarTermino();
  return os;
}
 
// Operador llamada a función
double CPolinomio::operator()( double x, double y )
{
  double v = 0;
  for ( int i = 0; i < NroTerminosAct; i++ )
    v += ppTermino[i]->ObtenerCoeficiente() *
         pow(x, ppTermino[i]->ObtenerExponenteDeX()) *
         pow(y, ppTermino[i]->ObtenerExponenteDeY());
  return v;
}
 
// Operador de conversión de CPolinomio a double
CPolinomio::operator double()
{
  return (*this)();
}