Caso de estudio: experimentos inmunologicos. … · Caso de estudio: experimentos inmunologicos. Laboratorio de PRO2. v0.1 3-11-2010 Generado por Doxygen 1.5.6 Thu Dec 2 18:04:38

Caso de estudio: experimentos inmunologicos. Laboratorio de PRO2.v0.1 3-11-2010

Generado por Doxygen 1.5.6

Thu Dec 2 18:04:38 2010

Índice general

1. Página principal 1

2. Índice de clases 3

2.1. Lista de clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

3. Indice de archivos 5

3.1. Lista de archivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

4. Documentación de las clases 7

4.1. Referencia de la Clase Celula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

4.1.1. Descripción detallada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

4.1.2. Documentación del constructor y destructor . . . . . . . . . . . . . . . . . . . . . 8

4.1.2.1. Celula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

4.1.2.2. ∼Celula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

4.1.3. Documentación de las funciones miembro . . . . . . . . . . . . . . . . . . . . . . 9

4.1.3.1. lucha_celulas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

4.1.3.2. es_vacia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

4.1.3.3. leer_celula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

4.1.3.4. escribir_celula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

4.1.4. Documentación de los datos miembro . . . . . . . . . . . . . . . . . . . . . . . . 10

4.1.4.1. ID_VACIA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

4.1.4.2. id . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4.1.4.3. i_tol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4.1.4.4. param . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4.2. Referencia de la Clase Organismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12



4.2.2.1. Organismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

4.2.2.2. ∼Organismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

II ÍNDICE GENERAL


4.2.3.1. anadir_id . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4.2.3.2. incrementar_victimas . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4.2.3.3. lucha_organismos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4.2.3.4. es_maligno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

4.2.3.5. num_victimas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

4.2.3.6. leer_organismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

4.2.3.7. escribir_organismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

4.2.3.8. simetricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4.2.3.9. lucha_arboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4.2.3.10. leer_arbol_celulas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

4.2.3.11. escribir_arbol_celulas_id . . . . . . . . . . . . . . . . . . . . . . . . . 18


4.2.4.1. celulas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

4.2.4.2. id . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

4.2.4.3. maligno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

4.2.4.4. victimas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

4.3. Referencia de la Clase Sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20



4.3.2.1. Sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

4.3.2.2. ∼Sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21


4.3.3.1. anadir_organismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

4.3.3.2. leer_sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

4.3.3.3. escribir_sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

4.3.3.4. luchas_org_cola . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

4.3.3.5. concatenar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4.3.3.6. escribir_sistema_cola . . . . . . . . . . . . . . . . . . . . . . . . . . . 25


4.3.4.1. def . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

4.3.4.2. mal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

4.3.4.3. id . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

5. Documentación de archivos 27

5.1. Referencia del Archivo Celula.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27


Generado el Thu Dec 2 18:04:38 2010 para Caso de estudio: experimentos inmunologicos. Laboratorio de PRO2. por Doxygen

ÍNDICE GENERAL III

5.2. Referencia del Archivo Celula.hpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28


5.3. Referencia del Archivo Organismo.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29


5.4. Referencia del Archivo Organismo.hpp . . . . . . . . . . . . . . . . . . . . . . . . . . . 30


5.5. Referencia del Archivo pro2.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31


5.5.2. Documentación de las funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

5.5.2.1. escribir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

5.5.2.2. main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

5.6. Referencia del Archivo Sistema.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33


5.7. Referencia del Archivo Sistema.hpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34



Capítulo 1

Página principal

El programa principal se encuentra en el módulo pro2.cpp. Atendiendo a los tipos de datos sugeridos en elenunciado, necesitaremos un módulo para representar el Sistema en el que se desarrollarán los experimen-tos, otro para el tipo Organismo y otro para el tipo Celula.

Comentarios:

En una resolución normal, comenzaríamos por considerar las operaciones necesarias para el progra-ma principal y las clasificaríamos en los diferentes módulos. Al pasar a su implementación, quizádescubriésemos que algún módulo necesita alguna operación adicional y la incorporaríamos en esemomento (sólo si es pública, es decir, si se usa en un módulo distinto al que pertenece). Sin embargo,en un documento de estas características, se presentan los módulos completamente acabados, sinnecesidad de reflejar el proceso que ha dado lugar a su especificación final.

En cuanto a los diagramas modulares que aparecen en este proyecto, notad que la relación de usoentre Organismo y Celula no se obtiene de forma explícita, ya que el segundo módulo no se usa enla especificación del primero. Sin embargo, podemos prever que nos la encontraremos en la secciónde implementación.

2 Página principal


Capítulo 2

Índice de clases

2.1. Lista de clases

Lista de las clases, estructuras, uniones e interfaces con una breve descripción:

Celula (Representa el conjunto de características y operaciones de las células ) . . . . . . . . . . 7Organismo (Representa la información y las operaciones asociadas a un organismo ) . . . . . . 12Sistema (Representa el sistema donde se desarrollan los experimentos ) . . . . . . . . . . . . . 20

4 Índice de clases


Capítulo 3

Indice de archivos

3.1. Lista de archivos

Lista de todos los archivos con descripciones breves:

Celula.cpp (Código de la clase Celula ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27Celula.hpp (Especificación de la clase Celula ) . . . . . . . . . . . . . . . . . . . . . . . . . . . 28Organismo.cpp (Código de la clase Organismo ) . . . . . . . . . . . . . . . . . . . . . . . . . . 29Organismo.hpp (Especificación de la clase Organismo ) . . . . . . . . . . . . . . . . . . . . . . 30pro2.cpp (Programa principal ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31Sistema.cpp (Código de la clase Sistema ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33Sistema.hpp (Especificación de la clase Sistema ) . . . . . . . . . . . . . . . . . . . . . . . . . 34

6 Indice de archivos


Capítulo 4

Documentación de las clases

4.1. Referencia de la Clase Celula

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

Métodos públicos

Celula (int N)

Creadora por defecto.

∼Celula ()

Destructora por defecto.

int lucha_celulas (const Celula &c2) const

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

bool es_vacia () const

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

void leer_celula ()

Operación de lectura.

void escribir_celula () const

Operación de escritura.

Atributos privados

int id

Identificador de la célula.

int i_tol

Indice de tolerancia.

8 Documentación de las clases

vector< double > param

Parámetros de la célula.

Atributos privados estáticos

static const int ID_VACIA = 0

Identificador especial para células vacias.

4.1.1. 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.

El hecho de que las células se lean en el contexto de la léctura de árboles de células que componen orga-nismos nos induce a definir el concepto de célula vacía para poder leer árboles siguiendo un formato deentrada parecido al de la sesión 7 de laboratorio, "Uso de listas y árboles" (en la que se define una "marca"para indicar subárbol vacío).

Definición en la línea 29 del archivo Celula.hpp.

4.1.2. Documentación del constructor y destructor

4.1.2.1. Celula::Celula (int N)


Precondición:

N>0

Postcondición:

El resultado es una célula de N parámetros con valores no determinados

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

8 {9 // Inicializa una celula a vacia e inicializa el vector de parámetros10 id = ID_VACIA;11 param = vector<double>(N);12 }

4.1.2.2. Celula::∼Celula ()



14 {}


4.1 Referencia de la Clase Celula 9

4.1.3. Documentación de las funciones miembro

4.1.3.1. 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 es: 1 <=> c1 vence a c2; 2 <=> c2 vence a c1; 3<=> no vence ninguna de las dos


17 {18 // Se trata de obtener la diferencia entre el número de posiciones de la primera19 // célula que superan a las de la segunda y viceversa. Después se compara dicha20 // diferencia con los indicadores de tolerancia.21 int i = 0;22 int dif = 0;2324 // Inv: dif = diferencia entre el número de posiciones en [0..i-1] en que c1 supera a c225 // y viceversa, 0<=i<=param.size()2627 while (i < param.size()) {28 if (param[i] > c2.param[i]) ++dif;29 else if (param[i] < c2.param[i]) --dif;30 ++i;31 }32 // Post1: dif = diferencia entre el número de posiciones totales en que33 // c1 supera a c2 y viceversa34 int n = 3;35 if (dif > c2.i_tol) n = 1;36 else if (dif < -i_tol) n = 2;37 return n;38 }

4.1.3.2. 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


41 {42 return id == ID_VACIA;43 }



4.1.3.3. void Celula::leer_celula ()


Precondición:

cierto

Postcondición:

Los parámetros del parámetro implícito pasan a ser los leídos del canal de entrada estándard


46 {47 // Simplemente lee todos los componentes de la célula teniendo en cuenta que si48 // el identificador es cero se trata de una celula "marca" y no es necesario continuar leyendo.49 id = readint();50 if (id != ID_VACIA) {51 i_tol = readint();52 for (int i = 0; i < param.size(); ++i) {53 param[i] = readdouble();54 }55 }56 }

4.1.3.4. void Celula::escribir_celula () const


Precondición:

cierto

Postcondición:

Se ha escrito el identificador del parámetro implícito por el canal de salida estándard


59 {60 // Análogamente, se trata sólo de escribir los componentes que nos interesan,61 // en este caso, segun el enunciado, el identificador de la célula.62 cout << id;63 }

4.1.4. Documentación de los datos miembro

4.1.4.1. const int Celula::ID_VACIA = 0 [static, private]

Identificador especial para células vacias.



4.1 Referencia de la Clase Celula 11

4.1.4.2. int Celula::id [private]

Identificador de la célula.


4.1.4.3. int Celula::i_tol [private]

Indice de tolerancia.


4.1.4.4. vector<double> Celula::param [private]

Parámetros de la célula.

param[i] contiene el parámetro i-esimo (0 < i < param.size()).


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

Celula.hppCelula.cpp



4.2. Referencia de la Clase Organismo

Representa la información y las operaciones asociadas a un organismo.

Métodos públicos

Organismo ()


∼Organismo ()


void anadir_id (int id)

Modificadora del identificador.

void incrementar_victimas ()

Modificadora del número de victimas.

int lucha_organismos (const Organismo &o2) const

Consultora del resultado de la lucha entre dos organismos.

bool es_maligno () const

Consultora de la malignidad del organismo.

int num_victimas () const

Consultora del número de victimas.

void leer_organismo (int N)


void escribir_organismo (bool estr) const


Métodos privados

bool simetricos (Arbre< Celula > &a1, Arbre< Celula > &a2) const

Comprobación de simetría de dos árboles.

pair< int, int > lucha_arboles (Arbre< Celula > &a1, Arbre< Celula > &a2) const

Lucha de dos árboles de células.

void leer_arbol_celulas (int N, Arbre< Celula > &a) const

Operación de lectura de un árbol de células.

void escribir_arbol_celulas_id (const Arbre< Celula > &a) const

Operación de escritura de un árbol de células.


4.2 Referencia de la Clase Organismo 13

Atributos privados

Arbre< Celula > celulas

Estructura celular del organismo.

int id

Identificador del organismo.

bool maligno

Indica si es maligno (true) o defensivo (false).

int victimas

Número de victimas del organismo.


Representa la información y las operaciones asociadas a un organismo.

Sus operaciones son las modificadoras de identificador y de número de organismos destruídos, las consul-toras de si un organismo es maligno y la de su número de víctimas, la que devuelve el resultado de unalucha de dos organismos, la de lectura (única que produce un organismo nuevo) y la de escritura.

Definición en la línea 21 del archivo Organismo.hpp.


4.2.2.1. Organismo::Organismo ()


Precondición:

cierto

Postcondición:

El resultado es un organismo vacío

Definición en la línea 11 del archivo Organismo.cpp.

11 {}

4.2.2.2. Organismo::∼Organismo ()



13 {}




4.2.3.1. void Organismo::anadir_id (int id)

Modificadora del identificador.

Precondición:

cierto

Postcondición:

El parámetro implícito pasa a tener a id como identificador


21 {22 this->id = id;23 }

4.2.3.2. void Organismo::incrementar_victimas ()

Modificadora del número de victimas.

Precondición:

cierto

Postcondición:

El parámetro implícito pasa a tener una víctima más en su cuenta


16 {17 ++victimas;18 }

4.2.3.3. int Organismo::lucha_organismos (const Organismo & o2) const

Consultora del resultado de la lucha entre dos organismos.

Precondición:

El parámetro implícito (o1) y o2 están compuestos por células con el mismo número de parámetros

Postcondición:

Retorna el resultado de la lucha entre o1 y o2, que es 0 <=> o1 y o2 resultan destruidos; 1 <=> o1resulta destruido y o2 no; 2 <=> o1 no resulta destruido y o2 sí; 3 <=> ni o1 ni o2 resultan destruidos




26 {27 // Ésta es la operación más importante del módulo. Dados dos organismos, hay28 // que decidir primero si van a luchar de verdad o no, es decir, si sus29 // estructuras celulares son simétricas o no. Por eso, introducimos la30 // operación auxiliar "simetricos" en la parte privada. Notad que en la31 // cabecera de la operación "simetricos" decimos que los parámetros han de32 // ser árboles de Celula, pero la operación es independiente del tipo de los33 // elementos del árbol, ya que éstos nunca se llegan a consultar. Asímismo,34 // debemos disponer de otra operación que aplique las luchas de las células35 // de dos árboles, sabiendo que son simétricos. Aquí sí es relevante el36 // hecho de que los árboles sean de células. Esta nueva operación privada se37 // llama "lucha_arboles".3839 int n;40 Arbre<Celula> aux1 = celulas;41 Arbre<Celula> aux2 = o2.celulas;42 if (simetricos(aux1, aux2)) {43 aux1 = celulas;44 aux2 = o2.celulas;45 pair<int, int> m = lucha_arboles(aux1, aux2);46 if (m.first == m.second) n = 0;47 else if (m.first < m.second) n = 1;48 else n = 2; // m.first > m.second49 }50 else n = 3;51 return n;52 }

4.2.3.4. bool Organismo::es_maligno () const

Consultora de la malignidad del organismo.

Precondición:

cierto

Postcondición:

El resultado es cierto si el parametro implícito es un organismo maligno y falso en caso contrario


105 {106 // Devuelve el valor del campo "maligno" del organismo correspondiente.107 return maligno;108 }

4.2.3.5. int Organismo::num_victimas () const

Consultora del número de victimas.

Precondición:

cierto

Postcondición:

El resultado es el número de organismos destruidos por el parámetro implícito




111 {112 // Devuelve el valor del campo "victimas" del organismo correspondiente.113 return victimas;114 }

4.2.3.6. void Organismo::leer_organismo (int N)


Precondición:

N>0

Postcondición:

El parámetro implícito es un organismo tomado del canal de entrada estándard formado por células deN parámetros


117 {118 // Esta operación simplemente lee la estructura celular del organismo e119 // inicializa el recuento de víctimas. Un árbol de células se lee igual que120 // un árbol de enteros. Suponemos que contamos con una marca de tipo Celula121 // para indicar que llegamos a un árbol vacío.122123 leer_arbol_celulas(N, celulas);124 maligno = readbool();125 victimas = 0;126 }

4.2.3.7. void Organismo::escribir_organismo (bool estr) const


Precondición:

cierto

Postcondición:

Se ha escrito el identificador del parámetro implíctio y el número de rivales que ha destruido por elcanal de salida estándard; si estr es cierto también se ha escrito su estructura celular


141 {142 // Escribimos los campos del organismo. Un árbol de células se escribe143 // igual que un árbol de enteros, suponiendo que (como es el caso) exista144 // una operación para escribir células.145 cout << id << " " << victimas;146 if (estr) escribir_arbol_celulas_id(celulas);147 cout << endl;148 }



4.2.3.8. bool Organismo::simetricos (Arbre< Celula > & a1, Arbre< Celula > & a2) const[private]

Comprobación de simetría de dos árboles.

Precondición:

a1 = A1; a2 = A2

Postcondición:

El resultado indica si A1 y A2 son simétricos


55 {56 bool b;57 if (a1.es_buit() or a2.es_buit()) b = a1.es_buit() and a2.es_buit();58 else {59 Arbre<Celula> fd1, fd2;60 a1.fills(fd1); // a1 = hi(A1); fd1 = hd(A2)61 a2.fills(fd2); // a2 = hi(A2); fd1 = hd(A2)62 b = simetricos(a1, fd2);63 // HI1: b indica si hi(A1) y hd(A2) son simétricos64 if (b) { b = simetricos(fd1, a2);65 // HI2: b indica si hd(A1) y hi(A2) son simétricos66 }67 }68 return b;69 }

4.2.3.9. pair< int, int > Organismo::lucha_arboles (Arbre< Celula > & a1, Arbre< Celula > &a2) const [private]

Lucha de dos árboles de células.

Precondición:

a1 y a2 son simétricos; a1 = A1; a2 = A2

Postcondición:

El primer componente del resultado es el número de células de A1 que vencen a su correspondiente enA2; el segundo es el número de células de A2 que vencen a su correspondiente en A1


72 {73 pair<int,int> n;7475 if (a1.es_buit()) {76 n.first = 0;77 n.second = 0;78 }79 else {80 int nraiz = a1.arrel().lucha_celulas(a2.arrel());81 n.first = 0;82 if (nraiz == 1) ++n.first;



83 n.second = 0;84 if (nraiz == 2) ++n.second;85 Arbre<Celula> fd1, fd2;86 a1.fills(fd1); // a1 = hi(A1); fd1 = hd(A2)87 a2.fills(fd2); // a2 = hi(A2); fd1 = hd(A2)88 pair<int,int> na = lucha_arboles(a1, fd2);89 // HI1: na.first = número de células de hi(A1) que vencen a su90 // correspondiente en hd(A2);91 // na.second = número de células de hd(A2) que vencen a su92 // correspondiente en hi(A1)93 pair<int,int> nb = lucha_arboles(fd1, a2);94 // HI2: nb.first = número de células de hd(A1) que vencen a su95 // correspondiente en hi(A2);96 // nb.second = número de células de hi(A2) que vencen a su97 // correspondiente en hd(a1)98 n.first += na.first + nb.first;99 n.second += nb.second + na.second;100 }101 return n;102 }

4.2.3.10. void Organismo::leer_arbol_celulas (int N, Arbre< Celula > & a) const [private]

Operación de lectura de un árbol de células.

Precondición:

N > 0; a es vacío

Postcondición:

a contiene el árbol de células leído de la entrada


129 {130 Arbre<Celula> a1, a2;131 Celula c(N);132 c.leer_celula();133 if (not c.es_vacia()) {134 leer_arbol_celulas(N, a1);135 leer_arbol_celulas(N, a2);136 a.plantar(c, a1, a2);137 }138 }

4.2.3.11. void Organismo::escribir_arbol_celulas_id (const Arbre< Celula > & a) const[private]

Operación de escritura de un árbol de células.

Precondición:

cierto

Postcondición:

Se ha escrito a por el canal de salida estándard




151 {152 if (not a.es_buit()) {153 Arbre<Celula> a1, a2;154 a1.fe(a);155 a2.fd(a);156 escribir_arbol_celulas_id(a1);157 cout << " ";158 a.arrel().escribir_celula();159 escribir_arbol_celulas_id(a2);160 }161 }


4.2.4.1. Arbre<Celula> Organismo::celulas [private]

Estructura celular del organismo.


4.2.4.2. int Organismo::id [private]

Identificador del organismo.


4.2.4.3. bool Organismo::maligno [private]

Indica si es maligno (true) o defensivo (false).


4.2.4.4. int Organismo::victimas [private]

Número de victimas del organismo.



Organismo.hppOrganismo.cpp



4.3. Referencia de la Clase Sistema

Representa el sistema donde se desarrollan los experimentos.

Métodos públicos

Sistema ()


∼Sistema ()


void anadir_organismo (Organismo &o, bool &sobrevive)

Modificadora que gestiona el intento de entrada de un organismo en el sistema.

void leer_sistema (int N)


void escribir_sistema (bool tipo, bool estr) const


Métodos privados

void luchas_org_cola (Cua< Organismo > &c, Organismo &o, bool &sobrevive) const

Lucha de un organismo contra los organismos de una cola.

void concatenar (Cua< Organismo > &c1, Cua< Organismo > &c2) const

Concatenación de colas de organismos.

void escribir_sistema_cola (const Cua< Organismo > &c, bool estr) const

Operación de escritura de una cola de organismos.

Atributos privados

Cua< Organismo > def

Cola de organismos defensivos.

Cua< Organismo > mal

Cola de organismos malignos.

int id

Primer número disponible de identificador de organismo.


4.3 Referencia de la Clase Sistema 21


Representa el sistema donde se desarrollan los experimentos.

Ofrece operaciones para introducir un organismo en el sistema, de lectura y escritura del sistema.

Definición en la línea 21 del archivo Sistema.hpp.


4.3.2.1. Sistema::Sistema ()


Precondición:

cierto

Postcondición:

El resultado es un sistema en que no ha entrado ningún organismo

Definición en la línea 7 del archivo Sistema.cpp.

8 {9 id = 0;10 }

4.3.2.2. Sistema::∼Sistema ()



12 {}


4.3.3.1. void Sistema::anadir_organismo (Organismo & o, bool & sobrevive)

Modificadora que gestiona el intento de entrada de un organismo en el sistema.

Precondición:

o es un organismo sin identificador

Postcondición:

El parámetro implícito contiene el estado del sistema después del intento de entrada del organismo o;o pasa a tener identificador y a contener el número de organismos que ha destruido; sobrevive indicasi o queda vivo en el parámetro implícito o no




15 {16 // Proporciona su identificador al nuevo organismo y organiza las luchas de17 // éste. Para ello, emplea la operación privada "luchas_org_cola" que lo enfrenta18 // a los de la cola correspondiente y obtiene la información necesaria.19 o.anadir_id(id);20 ++id;21 if (o.es_maligno()) {22 luchas_org_cola(def, o, sobrevive);23 if (sobrevive) mal.demanar_torn(o);24 }25 else {26 luchas_org_cola(mal, o, sobrevive);27 if (sobrevive) def.demanar_torn(o);28 }29 }

4.3.3.2. void Sistema::leer_sistema (int N)


Precondición:

El parámetro implícito es un sistema en que no ha entrado ningún organismo; N>0

Postcondición:

El parámetro implícito está formado por un grupo de organismos leídos por el canal de entrada están-dard y formados por celulas de N parámetros


105 {106 // Esta operación inicializa los componentes de un sistema nuevo, con la107 // posiblidad de leer y almacenar algunos organismos defensivos. El número de108 // éstos se proporciona al comienzo de la operación. Es equivalente a una109 // constructora però con la ventaja de permitir separar la construcción de la110 // lectura por el canal de entrada estandard.111112 int num;113 Organismo o;114 def.c_buida();115 mal.c_buida();116 num = readint();117 for (int i = 1; i <= num; ++i) {118 o.leer_organismo(N);119 o.anadir_id(i);120 if (o.es_maligno()) mal.demanar_torn(o);121 else def.demanar_torn(o);122 }123 id = num+1;124 }

4.3.3.3. void Sistema::escribir_sistema (bool tipo, bool estr) const


Precondición:

cierto



Postcondición:

Si tipo es cierto, se han escrito en el canal de salida estándard, por orden de identificador, los organis-mos defensivos del parámetro implícito, en caso contrario se han escrito los malignos; si estr es cierto,cada organismo se escribe con su estructura celular, en caso contrario sólo se escribe su identificador


127 {128 // Esta operación simplemente recorre la cola de los organismos pedidos,129 // proporcionando la información requerida, mediante una operación privada130 // auxiliar: "escribir_sistema_cola".131132 if (tipo) escribir_sistema_cola(def, estr);133 else escribir_sistema_cola(mal, estr);134 }

4.3.3.4. void Sistema::luchas_org_cola (Cua< Organismo > & c, Organismo & o, bool &sobrevive) const [private]

Lucha de un organismo contra los organismos de una cola.

Precondición:

c = C; C está ordenada crecientemente según los identificadores de sus organismos

Postcondición:

c contiene los organismos de C, ordenados crecientemente por identificador y con su contador devíctimas actualizado, excepto los que hayan muerto al enfrentarse con o; sobrevive indica si o quedavivo despues de sus enfrentamientos; o pasa a contener el número de organismos que ha destruido


32 {33 // Busca el primer organismo de la cola que consigue matar al organismo nuevo y34 // borra (y cuenta) todos los que resultan destruidos por éste. Para que el35 // borrado sea efectivo hace falta una cola auxiliar para ir guardando los36 // supervivientes. Al final, dicha cola permite construir la de salida mediante37 // una nueva operación privada auxiliar: "concatenar".3839 Organismo actual;40 int resultado;41 Cua<Organismo> aux;4243 sobrevive = true;4445 // Inv: sobrevive = ninguno de los elementos visitados de C destruye a o;46 // c = elementos no visitados de C;47 // aux = elementos visitados de C que sobreviven a la lucha con o,48 // con su contador de víctimas actualizado;49 // aux está ordenada crecientemente según los identificadores;50 // o tiene actualizado su contador de víctimas5152 while (not c.es_buida() and sobrevive) {53 actual = c.primer();54 resultado = o.lucha_organismos(actual);55 switch (resultado) {56 case 0: { // los dos mueren57 sobrevive = false; // no actualizamos las víctimas de actual



58 o.incrementar_victimas(); // porque éste ya no pertenece al sistema59 break;60 }61 case 1: { // o muere, actual sobrevive62 sobrevive= false;63 actual.incrementar_victimas();64 aux.demanar_torn(actual);65 break;66 }67 case 2: { // o sobrevive, actual muere68 o.incrementar_victimas();69 break;70 }71 case 3: { // los dos sobreviven72 aux.demanar_torn(actual);73 break;74 }75 }76 c.avancar();77 }7879 // Post1: aux contiene los organismos de C que se han enfrentado con o,80 // ordenados crecientemente por identificador y con su contador81 // de víctimas actualizado, excepto los que hayan muerto;82 // sobrevive indica si o queda vivo despues de sus enfrentamientos;83 // o pasa a contener el número de organismos que ha destruido.84 // si sobrevive entonces c está vacía8586 // si quedan organismos en c han de traspasarse a aux87 concatenar(aux,c);88 // ahora aux contiene lo que queremos que sea c89 c = aux;90 }

4.3.3.5. void Sistema::concatenar (Cua< Organismo > & c1, Cua< Organismo > & c2) const[private]

Concatenación de colas de organismos.

Precondición:

c1 = C1; c2 = C2

Postcondición:

c1 contiene los elementos de C1 seguidos de los elementos de C2 en el orden en que estaban


93 {94 // Inv: c1 contiene los elementos de C1 seguidos de los95 // elementos visitados de C2 en el orden en que estaban;96 // c2 contiene la parte no visitada de la C29798 while (not c2.es_buida()) {99 c1.demanar_torn(c2.primer());100 c2.avancar();101 }102 }



4.3.3.6. void Sistema::escribir_sistema_cola (const Cua< Organismo > & c, bool estr) const[private]

Operación de escritura de una cola de organismos.

Precondición:

cierto

Postcondición:

Se han escrito en el canal estándar de salida los organismos de c, por orden de identificador; si estres cierto, cada organismo se escribe con su estructura celular, en caso contrario sólo se escribe suidentificador


137 {138 Cua<Organismo> aux = c;139 while (not aux.es_buida()) {140 aux.primer().escribir_organismo(estr);141 aux.avancar();142 }143 }


4.3.4.1. Cua<Organismo> Sistema::def [private]

Cola de organismos defensivos.

Ordenada crecientemente por el id de sus componentes


4.3.4.2. Cua<Organismo> Sistema::mal [private]

Cola de organismos malignos.

Ordenada crecientemente por el id de sus componentes


4.3.4.3. int Sistema::id [private]

Primer número disponible de identificador de organismo.



Sistema.hppSistema.cpp




Capítulo 5

Documentación de archivos

5.1. Referencia del Archivo Celula.cpp

Código de la clase Celula.


Código de la clase Celula.

Definición en el archivo Celula.cpp.

28 Documentación de archivos

5.2. Referencia del Archivo Celula.hpp

Especificación de la clase Celula.

Clases

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


Especificación de la clase Celula.

Definición en el archivo Celula.hpp.


5.3 Referencia del Archivo Organismo.cpp 29

5.3. Referencia del Archivo Organismo.cpp

Código de la clase Organismo.


Código de la clase Organismo.

Definición en el archivo Organismo.cpp.



5.4. Referencia del Archivo Organismo.hpp

Especificación de la clase Organismo.

Dependencia gráfica adjunta para Organismo.hpp:

Organismo.hpp

Celula.hpp

Clases

class OrganismoRepresenta la información y las operaciones asociadas a un organismo.


Especificación de la clase Organismo.

Definición en el archivo Organismo.hpp.


5.5 Referencia del Archivo pro2.cpp 31

5.5. Referencia del Archivo pro2.cpp

Programa principal.

Dependencia gráfica adjunta para pro2.cpp:

pro2.cpp

Sistema.hpp

Organismo.hpp

Celula.hpp

Funciones

void escribir (int muertos, bool sobrevive)

Escritura de los resultados de la opción -1.

int main ()


Programa principal.

Estamos suponiendo que los datos leídos siempre son correctos, ya que no incluímos comprobaciones alrespecto. Por último, puesto que los datos de los organismos y células son naturales (identificadores, ...)usaremos números negativos para las opciones.

Definición en el archivo pro2.cpp.

5.5.2. Documentación de las funciones

5.5.2.1. void escribir (int muertos, bool sobrevive)

Escritura de los resultados de la opción -1.

Definición en la línea 42 del archivo pro2.cpp.

43 {44 // Escribe el entero y el booleano con el formato de la salida45 // de la práctica.4647 cout << muertos << " ";48 cout << sobrevive;49 cout << endl;50 }



5.5.2.2. int main ()

Definición en la línea 52 del archivo pro2.cpp.

53 {54 int N; // Número de parámetros de las células55 N = readint();56 Sistema S;57 S.leer_sistema(N);58 int op; // Código de operación59 op = readint();60 while (op != -3) {61 if (op == -1 ) {62 Organismo O;63 O.leer_organismo(N);64 bool sobrevive;65 S.anadir_organismo(O, sobrevive);66 cout << "Entrada del nuevo organismo" << endl;67 escribir(O.num_victimas(), sobrevive);68 }69 else if (op == -2) {70 bool tipo = readbool();71 bool estr = readbool();72 if (tipo){73 if (estr)74 cout << "Defensivos del sistema con estructura" << endl;75 else76 cout << "Defensivos del sistema sin estructura" << endl;77 }78 else {79 if (estr)80 cout << "Malignos del sistema con estructura" << endl;81 else82 cout << "Malignos del sistema sin estructura" << endl;83 }84 S.escribir_sistema(tipo, estr);85 }86 op = readint();87 }88 }


5.6 Referencia del Archivo Sistema.cpp 33

5.6. Referencia del Archivo Sistema.cpp

Código de la clase Sistema.


Código de la clase Sistema.

Definición en el archivo Sistema.cpp.



5.7. Referencia del Archivo Sistema.hpp

Especificación de la clase Sistema.

Dependencia gráfica adjunta para Sistema.hpp:

Sistema.hpp

Organismo.hpp

Celula.hpp

Clases

class SistemaRepresenta el sistema donde se desarrollan los experimentos.


Especificación de la clase Sistema.

Definición en el archivo Sistema.hpp.


Índice alfabético

∼CelulaCelula, 8

∼OrganismoOrganismo, 13

∼SistemaSistema, 21

anadir_idOrganismo, 14

anadir_organismoSistema, 21

Celula, 7∼Celula, 8Celula, 8es_vacia, 9escribir_celula, 10i_tol, 11id, 10ID_VACIA, 10leer_celula, 9lucha_celulas, 9param, 11

Celula.cpp, 27Celula.hpp, 28celulas

Organismo, 19concatenar

Sistema, 24

defSistema, 25

es_malignoOrganismo, 15

es_vaciaCelula, 9

escribirpro2.cpp, 31

escribir_arbol_celulas_idOrganismo, 18

escribir_celulaCelula, 10

escribir_organismoOrganismo, 16

escribir_sistemaSistema, 22

escribir_sistema_colaSistema, 24

i_tolCelula, 11

idCelula, 10Organismo, 19Sistema, 25

ID_VACIACelula, 10

incrementar_victimasOrganismo, 14

leer_arbol_celulasOrganismo, 18

leer_celulaCelula, 9

leer_organismoOrganismo, 16

leer_sistemaSistema, 22

lucha_arbolesOrganismo, 17

lucha_celulasCelula, 9

lucha_organismosOrganismo, 14

luchas_org_colaSistema, 23

mainpro2.cpp, 31

malSistema, 25

malignoOrganismo, 19

num_victimasOrganismo, 15

Organismo, 12∼Organismo, 13

36 ÍNDICE ALFABÉTICO

anadir_id, 14celulas, 19es_maligno, 15escribir_arbol_celulas_id, 18escribir_organismo, 16id, 19incrementar_victimas, 14leer_arbol_celulas, 18leer_organismo, 16lucha_arboles, 17lucha_organismos, 14maligno, 19num_victimas, 15Organismo, 13simetricos, 16victimas, 19

Organismo.cpp, 29Organismo.hpp, 30

paramCelula, 11

pro2.cpp, 31escribir, 31main, 31

simetricosOrganismo, 16

Sistema, 20∼Sistema, 21anadir_organismo, 21concatenar, 24def, 25escribir_sistema, 22escribir_sistema_cola, 24id, 25leer_sistema, 22luchas_org_cola, 23mal, 25Sistema, 21

Sistema.cpp, 33Sistema.hpp, 34

victimasOrganismo, 19


Documents

Caso de estudio: experimentos inmunologicos. … · Caso de estudio: experimentos inmunologicos. Laboratorio de PRO2. v0.1 3-11-2010 Generado por Doxygen 1.5.6 Thu Dec 2 18:04:38