Vector.hpp

Go to the documentation of this file.

// Clase para el trabajar con vectores de punto flotante                                    //
//                                                                                          //
//                                                                                          //
// Análisis y Diseño y Programación:                                                        //
//                                                                                          //
// Nombre:   Antonio Carrillo Ledesma                                                       //
// E-mail:   acl@www.mmc.geofisica.unam.mx                                                  //
// Página:   http://www.mmc.geofisica.unam.mx/acl                                           //
//                                                                                          //
//                                                                                          //
// Este programa es software libre. Puede redistribuirlo y/o modificarlo                    //
// bajo los términos de la Licencia Pública General de GNU según es                         //
// publicada por la Free Software Foundation, bien de la versión 2 de                       //
// dicha Licencia o bien (según su elección) de cualquier versión                           //
// posterior.                                                                               //
//                                                                                          //
// Este programa se distribuye con la esperanza de que sea útil, pero SIN                   //
// NINGUNA GARANTÍA, incluso sin la garantía MERCANTIL implícita o sin                      //
// garantizar la CONVENIENCIA PARA UN PROPÓSITO PARTICULAR. Véase la                        //
// Licencia Pública General de GNU para más detalles.                                       //
//                                                                                          //
// Debería haber recibido una copia de la Licencia Pública General junto                    //
// con este programa. Si no ha sido así, escriba a la Free Software                         //
// Foundation, Inc., en 675 Mass Ave, Cambridge, MA 02139, EEUU.                            //
//                                                                                          //
//                                                                                          //


#ifndef __Vector__
#define __Vector__

#include "Definiciones.hpp"
#include "Vector_Base.hpp"






class Vector: public Vector_Base
{
protected:


   ldouble *V;


   void solicitaMemoria(const int col, const ldouble val);



   void liberaMemoria(int tp)
   {
      delete []V;
      V = NULL;
      if (tp)
      {
         delete []Nmb;
         Nmb = NULL;
      }
   }

public:

   Vector(void) : Vector_Base()
   {
      solicitaMemoria(1,0);
      asignaNombre("Sin Nombre");
   }


   Vector(Vector &vec) : Vector_Base()
   {
      solicitaMemoria(vec.columnas(),0);
      asignaNombre(vec.nombre());
      for (int i = 0; i < Col; i++) V[i] = vec.retorna(i);
   }


   Vector(const int col) : Vector_Base()
   {
      solicitaMemoria(col,0.0);
      asignaNombre(" ");
   }


   Vector(const int col, const ldouble val)  : Vector_Base()
   {
      solicitaMemoria(col, val);
      asignaNombre(" ");
   }


   Vector(const int col, const ldouble val, const char *nmb)  : Vector_Base()
   {
      solicitaMemoria(col, val);
      asignaNombre(nmb);
   }


   Vector(const int col, const char *nmb) : Vector_Base()
   {
      solicitaMemoria(col,0.0);
      asignaNombre(nmb);
   }

   ~Vector()
   {
      liberaMemoria(1);
   }


   void redimensiona(int ncol)
   {
      liberaMemoria(0);
      solicitaMemoria(ncol,0.0);
   }



   void inicializa(const ldouble val);



   inline ldouble operator [] (size_t col)
   {
      return retorna(col);
   }


   inline ldouble operator () (size_t col)
   {
      return retorna(col);
   }


#ifdef DEPURAR

   inline void asigna(const int col, const ldouble val)
   {
      if (col < 0 || col >= Col)
      {
         visualizaInformacion();
         printf("Error indice desbordado (%d)\n",col);
         exit(1);
      }
      V[col] = val;
   }



   inline ldouble retorna(const int col)
   {
      if (col < 0 || col >= Col)
      {
         visualizaInformacion();
         printf("Error indice desbordado (%d)\n", col);
         exit(1);
      }
      return V[col];
   }

#else

   inline void asigna(const int col, const ldouble val)
   {
      V[col] = val;
   }



   inline ldouble retorna(const int col)
   {
      return V[col];
   }
#endif


   void visualiza(const int tp, int nl = 0, int num = 0);


   void copia(Vector *a);


   void convierte(ldouble *a, int tam);


   void suma(Vector *a, Vector *b);


   void suma(Vector *a);


   void resta(Vector *a, Vector *b);


   void resta(Vector *a);


   void multiplica(ldouble esc);


   ldouble normaInf(void);


   ldouble productoPunto(void);


   ldouble productoPunto(Vector *a);


   int esVectorCero(void);


   int esCadaEntradaMasPequeno(double eps);


   inline ldouble tamano(void)
   {
      ldouble t = (((long) sizeof(V) * Col) / 1024.0);
      return t;
   }

   inline void visualizaInformacion(void)
   {
      printf("\nVector \"%s\" de dimensión: %d \n",Nmb,Col);
   }

};

#endif