Laboratorio de PRO2. Caso de estudio: experimentos inmunologicos.  v7.0 13-11-2017
Métodos públicos | Métodos públicos estáticos | Atributos privados | Atributos privados estáticos | Lista de todos los miembros
Referencia de la Clase Celula

Representa el conjunto de características y operaciones de las células. Más...

Métodos públicos

 Celula ()
 Creadora por defecto. Más...
 
int lucha_celulas (const Celula &c2) const
 Consultora que determina el resultado de la lucha entre dos células. Más...
 
bool es_vacia () const
 Consultora que indica si la célula es vacía. Más...
 
int num_param ()
 Consultora del número de parámetros de una célula. Más...
 
void leer (int N)
 Operación de lectura. Más...
 
void escribir () const
 Operación de escritura. Más...
 

Métodos públicos estáticos

static int id_vacia ()
 Consultora del identificador especial de células vacías. Más...
 

Atributos privados

int id
 Identificador de la célula. Más...
 
int i_tol
 Indice de tolerancia. Más...
 
vector< double > param
 Parámetros de la célula. Más...
 

Atributos privados estáticos

static const int ID_VACIA = 0
 Identificador especial para células vacias. Más...
 

Descripción detallada

Representa el conjunto de características y operaciones de las células.

Ofrece la operación de lucha entre células y las operaciones de lectura y escritura.

Dado que vamos a necesitar leer árboles de células, definimos el concepto de célula vacía para disponer de un formato de entrada parecido al de las anteriores sesiones de laboratorio, en las que se emplea una "marca" para indicar la lectura de un árbol vacío.

Definición en la línea 30 del archivo Celula.hh.

Documentación del constructor y destructor

Celula::Celula ( )

Creadora por defecto.

Precondición
cierto
Postcondición
El resultado es una célula vacía, con índice de tolerancia cero y cero parámetros
Coste
Constante

Definición en la línea 7 del archivo Celula.cc.

8 {
9  // Inicializa una célula con el id de célula vacía
10  id = ID_VACIA;
11  i_tol = 0;
12 }
static const int ID_VACIA
Identificador especial para células vacias.
Definition: Celula.hh:35
int i_tol
Indice de tolerancia.
Definition: Celula.hh:39

Documentación de las funciones miembro

int Celula::lucha_celulas ( const Celula c2) const

Consultora que determina el resultado de la lucha entre dos células.

Precondición
El parámetro implícito (c1) y c2 tienen el mismo número de parámetros
Postcondición
Retorna el resultado de la lucha entre c1 y c2, que vale 1 si y solo si c1 vence a c2; 2 si y solo si c2 vence a c1; 3 si y solo si no vence ninguna de las dos
Coste
Lineal respecto al número de parámetros de una célula

Definición en la línea 14 del archivo Celula.cc.

15 {
16 
17  if (param.size()!=c2.param.size()) throw PRO2Excepcio("Las dos células han de tener el mismo número de parámetros");
18 
19  // Se trata de obtener la diferencia entre el número de posiciones de la primera
20  // célula que superan a las de la segunda y viceversa. Después se compara dicha
21  // diferencia con los indicadores de tolerancia.
22  int i = 0;
23  int dif = 0;
24 
25  // Inv: dif = diferencia entre el número de posiciones en [0..i-1] en que c1 supera a c2
26  // y viceversa, 0<=i<=param.size()
27 
28  while (i < param.size()) {
29  if (param[i] > c2.param[i]) ++dif;
30  else if (param[i] < c2.param[i]) --dif;
31  ++i;
32  }
33  // Post1: dif = diferencia entre el número de posiciones totales en que
34  // c1 supera a c2 y viceversa
35  int n = 3;
36  if (dif > c2.i_tol) n = 1;
37  else if (dif < -i_tol) n = 2;
38  return n;
39 }
vector< double > param
Parámetros de la célula.
Definition: Celula.hh:41
int i_tol
Indice de tolerancia.
Definition: Celula.hh:39
bool Celula::es_vacia ( ) const

Consultora que indica si la célula es vacía.

Precondición
cierto
Postcondición
El resultado indica si la célula es vacía o no
Coste
Constante

Definición en la línea 41 del archivo Celula.cc.

42 {
43  return id == ID_VACIA;
44 }
static const int ID_VACIA
Identificador especial para células vacias.
Definition: Celula.hh:35
int Celula::num_param ( )

Consultora del número de parámetros de una célula.

Precondición
cierto
Postcondición
El resultado es el número de parámetros de una célula
Coste
Constante

Definición en la línea 46 del archivo Celula.cc.

46  {
47  return param.size();
48 }
vector< double > param
Parámetros de la célula.
Definition: Celula.hh:41
int Celula::id_vacia ( )
static

Consultora del identificador especial de células vacías.

Precondición
cierto
Postcondición
El resultado es el identificador de célula vacía
Coste
Constante

Definición en la línea 50 del archivo Celula.cc.

51 {
52  return ID_VACIA;
53 }
static const int ID_VACIA
Identificador especial para células vacias.
Definition: Celula.hh:35
void Celula::leer ( int  N)

Operación de lectura.

Precondición
N>0, el canal de entrada estándar contiene un entero; si dicho entero no corresponde a un identificador de célula vacía, a continuación contiene otro entero y N doubles
Postcondición
El parámetro implícito pasa a tener un identificador (el primer entero del canal de entrada estándar); si éste no es el de una célula vacía, el p.i. también tendrá un índice de tolerancia y N parámetros nuevos, leídos del canal de entrada estándar
Coste
Lineal respecto a N (número de parámetros de una célula)

Definición en la línea 55 del archivo Celula.cc.

56 {
57  // Simplemente lee todos los componentes de la célula teniendo en cuenta que si
58  // el identificador es cero se trata de una celula "marca" y no es necesario continuar leyendo.
59 
60  if (N<=0) throw PRO2Excepcio("La celula ha de tener N parametros (N>0)");
61 
62  cin >> id;
63  if (id != ID_VACIA) {
64  cin >> i_tol;
65  param = vector<double> (N);
66  for (int i = 0; i < N; ++i) {
67  cin >> param[i];
68  }
69  }
70 }
vector< double > param
Parámetros de la célula.
Definition: Celula.hh:41
int id
Identificador de la célula.
Definition: Celula.hh:37
static const int ID_VACIA
Identificador especial para células vacias.
Definition: Celula.hh:35
int i_tol
Indice de tolerancia.
Definition: Celula.hh:39
void Celula::escribir ( ) const

Operación de escritura.

Precondición
cierto
Postcondición
Se ha escrito el identificador del parámetro implícito por el canal de salida estándard
Coste
Lineal respecto al número de parámetros de una célula

Definición en la línea 72 del archivo Celula.cc.

73 {
74  // Análogamente, se trata sólo de escribir los componentes que nos interesan,
75  // en este caso, según el enunciado, el identificador de la célula.
76  cout << id;
77 }
int id
Identificador de la célula.
Definition: Celula.hh:37

Documentación de los datos miembro

const int Celula::ID_VACIA = 0
staticprivate

Identificador especial para células vacias.

Definición en la línea 35 del archivo Celula.hh.

int Celula::id
private

Identificador de la célula.

Definición en la línea 37 del archivo Celula.hh.

int Celula::i_tol
private

Indice de tolerancia.

Definición en la línea 39 del archivo Celula.hh.

vector<double> Celula::param
private

Parámetros de la célula.

Definición en la línea 41 del archivo Celula.hh.


La documentación para esta clase fue generada a partir de los siguientes ficheros: