Duda básica ADA

QuitCat

Tengo que hacer una práctica que debería ser relativamente sencilla, que trata unos grafos conexos, con unos pesos , etc.. La historia es que lo tenemos que hacer en ADA , algo en lo que nunca nos han explicado absolutamente nada.
He conseguido leer de un fichero y que me lo muestre por pantalla. El siguiente paso es que quiero con los datos de ese fichero , rellenar un array bidimensional.
El error me al compilar cuando quiero asignar el valor que leo , en la posicion del array(x,y). Vamos , que no se como asignar el valor que he leido a la posición del array que quiero.

WITH Text_IO;
USE Text_IO;


procedure Main is
   f: Text_IO.File_Type;
   N: Integer;
   -- Instanciación del paquete genérico Text_IO.Integer_IO
   -- con el tipo Integer.
   package Int_IO is new Text_IO.Integer_IO (Integer);
   nodos:Integer;
   x:Integer;
   y:Integer;
   type A is range 0..100;
   type B is range 0..100;
   type tabla is array(POSITIVE range <>,
                       POSITIVE range <>) of INTEGER;
begin
   Text_IO.Open(File => f,
                Mode => Text_IO.In_File,
                Name => "enteros.txt",
                Form => "");
   Int_IO.Get (File  => f,
               Item  => nodos);
   while not Text_IO.End_Of_File (f) loop
      Int_IO.Get (File  => f,
                  Item  => N);
      x:=N;
      Int_IO.Get (File  => f,
                  Item  => N);
      y:=N;
      Int_IO.Get (File  => f,
                  Item  => N);
      tabla(x,y):= x;
      Int_IO.Put (N);
   end loop;
   Text_IO.Close(File => f);
   null;
   
end Main;

A ver si me podeis echar una mano , gracias.

SicKneSs

Hola,

porqué parametrizas asi ?? basta con poner los valores como ej Open(F, "In_file", "enteros.txt)
al igual, que no hace falta poner el paquete TexT_Io delante de cada funcion, puesto que has declarado F como Fichero de texto y resulta redundante.

Aver, estas leyendo una linea (N) y se lo asignas a un entero!!! imcompatibilidad de tipos. recuerda que ADA es iun lenguaje fuertemente tipado.

Haces el bucle mal, estas leyendo 3 linas en una sola iteración, vas a acabar leyendo lineas que no existen.... para eso está el while not End_of_file(N)...

1 respuesta
QuitCat

#2 La estructura mas o menos la he copiado de un ejemplo , y ya te digo, no he visto nunca nada en ada.
Lo del bucle vale ,se que esta mal . Pero voy a tener un fichero tal que así

numero numero numero
numero numero numero
numero numero numero

y lo que queria era probar simplemente de forma rapida si conseguia leer y asignar el valor, de hecho crei que en N estaba leyendo un entero, por lo de " Int_IO.Get". Asi que no se , como puedo leer un entero y asignarlo a esa posicion del array?

SicKneSs

en el fichero hay enteros ? uno por fila ?

En cualquier caso, Te está dando el error, porque La funcion Get(F,linea) te devuelve un String. y tu después estás intentando acceder a los indices del array (positive range <>) con ese String.

lo más fácil es convertir ese String en un entero, creo que era algo asi

Integer (N);
1 respuesta
QuitCat

#4 En el fichero hay 3 numeros por linea , pongamos , que algo así :
3
124
234
312

Ese primer numero lo cojo(O eso creia). ¿Y en vez de coger la linea entera , no es posible ir cogiendo cada numero de uno en uno?

T

Los de EUI te estamos espiando...

1 respuesta
QuitCat

#6 Pues tirate el rollo y pasame un crokis a ver como se hace esta mierda jaja

Kenji-

Puedes colgar el enunciado de la práctica??

Os dejan/tenéis TADs ya implementados para usar grafos/conjuntos/listas, ... ??

1 respuesta
QuitCat

#8
http://www.dia.eui.upm.es/cgi-bin/asigfram.pl?cual=ICalg_com&nombre=Algor%EDtmica%20y%20Complejidad

No solo no tenemos/nos dejan ningun TAD ya implementado , sino que NUNCA hemos dado nada en ADA.
Lo estoy haciendo usando Matrices de Adyacencia ,el apartado 2 ya lo tengo. Ahora estoy intentando sacar el apartado 1 .
Hasta donde sé , creo que la corrección es automática , pasa X pruebas y dependiendo de cuantas haga bien tienes una nota u otra. Espero que no influya lo enrevesado que sea el algoritmo/forma de hacerlo , porque no estoy siguiendo ningún algoritmo conocido de resolución de grafos( Prim, Kruskal , DFS , ... )

1 respuesta
Kenji-

#9 hostiaputa... estáis jodidos entonces. xDD

Esta noche le echo un vistazo y te cuento...
Creo que es la práctica A.. no?

En el apartado 1, tengo algunas preguntas:

  • te dan nodo inicial??
  • has manejado conjuntos y listas??
1 respuesta
QuitCat

#10 Si practica A. El nodo inicial se coge el menor , en este caso , el nodo 1.
Hemos "manejado conjuntos" y listas en la teoria , en papel-pseudocodigo-pizarra , no se si me explico. No lo hemos usado en ADA , ni hemos programado nada con ello para usarlo y demas.

Por eso lo estoy haciendo con matrices de adyacencia , que me parece a priori mas facil. Si nos hubiesen enseñado a usar conjuntos y listas en ADA , seguramente nos habría sido mas facil a todos

2 respuestas
Kenji-

#11 vale... y tendrás que hacer el ADS, el ADB y el programa principal, no??

Kenji-

#11 ... discúlpame, pero creo que el enunciado tiene un "algo" raro.

Siguiendo el grafo del apartado A, cuando te dice lo siguiente:
[Nodo origen] [Nodo destino] [Cuello Botella]
1 - 1 - 0 OK
1 - 2 - 3 OK
1 - 3 - 2 ???? <-- Explícame esto, el valor del arco de cuello de botella entre el nodo 1 y 3 es de valor 1. Hace 1-4, 4-5, 5-3....??
1 - 4 - 2 OK
1 - 5 - 2 OK , va por camino 1-4 coste 2, 4-5 coste 3, el cuello de botella es el mínimo = 2.

Es que me estoy re-leyendo el enunciado para ver que me acuerdo y estoy mirando con diagramas cómo puedo hacerlo. Cuando los termine, los escaneo y los posteo.

Pero vamos, no sé si tenéis que hacer memoria...

1 respuesta
QuitCat

#13 Se trata de que el cuello de botella sea el menor posible , o lo que es lo mismo , que el ancho de banda minimo sea el mayor posible.
Cuando va de 1 a 3 , el menor cuello de botella es 2. ¿Porque?Porque no usa la "arista/conexion" directa que tiene cuello de botella "1". Usa un camino optimo donde encuentra menor cuello de botella , que es pasando por el nodo 4,luego 5 y por ultimo el 3 , para así llegar al nodo 3 con un cuello de botella = 2 .

De hecho la practica trata de eso , de solucionar e grafo para conseguir el MST ( Arbol de recubrimiento minimo , o M.Spanning Tree , creo que era así) , para conseguir las conexiones optimas y que el cuello de botella entre todas las conexiones sean las menores posibles.

A ver si mañana intento otra vez el apartado 1. El 2 ya lo tengo hecho.

1 respuesta
Kenji-

Yo le estoy dando vueltas por aquí.. #14

Lo malo, que no sé que estructuras tenéis en cabeza para defenderos, porque lo más sencillo que se me ocurre con "conjunto de visitados" para no repetir caminos, y lista solución para luego encontrar el camino más óptimo, no sé si podréis usarlo vosotros.

Se me ocurre lo siguiente, tomando como origen 1 y final 5.

  • Leo nodos conexos de 1, los meto a un conjunto, una vez dentro de aquí, voy seleccionando como posible candidatos y voy moviendo el origen y jugando con la lista.
    Ejemplo:
    Primer paso:
    Origen 1- fin 5 -- Posibles: 1-2, 1-3, 1-4 = Lista solución: 1
    Seleccionamos primero:
    Origen 2- fin 5 -- Posibles: 2-5 = lista solución: 1,2.
    Selecciono siguiente:
    Origen 5- fin 5 -- Posibles: 0 = lista solución: 1,2,5. CuelloBotella 1.

Volvemos a primer paso:
Origen 3 - fin 5 -- Posibles: 3-5 = lista solución: 1,3
Selecciono siguiente:
Origen 5 - fin 5 -- Posibles: 0 = lista solución: 1,3,5. CuelloBotella 1.
Comparo con anterior lista, me quedo con el mejor. (en este caso, cualquiera)

Volvemos al primer paso:
Origen 4 - fin 5 -- Posibles: 4-5 = lista solución: 1,4
Selecciono siguiente:
Origen 5 - fin 5 -- Posibles: 0 = lista solución: 1, 4, 5. CuelloBotella 2.
Comparo con anterior lista, me quedo con el mejor. En este caso, la lista: 1, 4, 5.

Cómo no tengo más nodos en las bolsas, ni nuevas listas de estudio, finalizo poniendo el coste de cuelloBotella en el txt.

1 respuesta
QuitCat

#15 Como no manejo ADA y no se como van las listas(que seguramente sea lo mas fácil) , lo hecho de una forma un poco chapucera con 3 for y usando matriz de adyacencia.(array bidimensional).

Hacer "Nodos-1" veces (el nº de aristas que tiene un arbol de recubrimiento) lo siguiente :

-Busca la arista con mayor valor de todas que una (u) y (v) , y que ademas (u) este marcado como visitado , y (v) no lo este.
-Una vez la he encontrado, guardo esa arista( Las guardo en otro array de adyacencia solucion) , y la elimino/saco del primer array para que no la vuelva a buscar.)

De hecho yo ya tengo el arbol de recubrimiento hecho , es decir , ya tendria en matriz de adyacencia que aristas forman el arbol y solo me faltaría recorrerlo desde cada nodo hacia todos los restantes , que debería ser fácil , pero con arrays me estoy complicando demasiado. A ver si mañana le echo un rato y lo intento enforcar de otra forma.

1 respuesta
Kenji-

#16 ... uhmm.

Tienes que doblar los costes, es decir 1-3 es el mismo coste de arista/arco que 3-1.

Por lo demás tiene buena pinta. Excepto, porque imagínate que te lleva a un nodo trampa.

Empezamos el viaje entre la elección de costes de cuello botella: 1 - 3 - 5 --> coges el 5
Y ahora te lleva a otro que los costes sean: 1 - 1 --> Cagada.

Puede que el más óptimo fuera coger 3 y luego quizás tengan un coste 2.

Es decir,... tienes que empezar por una solución y bañar todas, porque sino, puede que no te de la correcta.

EDITO;
Discúlpame por lo que voy a decir... pero vaya mierda de temario, no te explican nada de ADA, ni te dan ayuda.

RE-EDITO:
Me estoy dando cuenta de que si no tienes realizado aunque sea un TAD de listas, es simplemente, muy jodido de hacer.

Voy a intentar hacerlo, aunque no logro que me funcione ada-gide en mi pc.

Kenji-

Buenas #1, he intentado hacerlo con 4 arrays. Sin tener un tad de gráfos, listas,... está jodida la cosa.

He intentado hacerlo recursivo, en plan "árbol", pero se complica el trabajar con los arrays.

Tengo, una array de visitados(n,m), tengo otro array de botella(n,m), otro de solución(n) y último de actual(n).

El algoritmo, lo tengo en papel, no sé si compila porque no me funciona el ADA-GIDE. Y poco más...

1 respuesta
QuitCat

#18 Yo con arrays , una vez tengo el del apartado 2 , no consigo sacar el final por decirlo asi... Solo con arrays es MUY complicado, me estoy volviendo loco ya

1 respuesta
Kenji-

ufff... a ver... te lo pongo un poco pseudocódigo más código de ADA. #19

PROCEDURE esperoquefuncione (Array_visitados IN OUT, Array_cuellobotella, array_visitados, array_solucion IN OUT, nodo_i IN OUT, nodo_f, coste IN OUT)
integer posicion :=1 ;

-- En caso de que ya termine una solución.
IF nodo_i == nodo_f THEN
   -- función que recorre la Matriz solución e inserta el último elemento nodo_i
   InsertarenSolucion (nodo_i,array_visitados);
   -- Comprobamos si es una solución factible con coste de cuello de botella menor
   IF coste > CosteSol (array_visitados, Array_cuellobotella) THEN
      coste:= CosteSol (array_visitados, Array_cuellobotella);
      borro_entera(array_solucion);
      copio (array_visitados,array_solucion);
   END IF;
ELSE
  -- Vamos a ver que pasa si no es el final ya
  -- Creamos una función que compruebe el nodo inicio en la array y no sale mientras tenga posibles viajes, y me devuelve la posición del siguiente.
   WHILE Todos_visitados(Array_visitados, nodo_inicio, posicion) LOOP
   --  nodo inicio actúa como x, y nodo posición cómo y.
   -- Añadimos la nueva posición al array de visitados.
      nuevoVistiado (array_visitados, posicion);
      esperoquefuncione(Array_visitados, Array_cuellobotella, array_visitados, array_solucion, posicion (<-- ATENTO), nodo_f, coste)
      borro_ultimo_visitado(array_vistados, posicion);
   END LOOP; 
END IF;

Lo que hago aquí es:
Cojo un elemento, y busco el camino, cuando lo tengo busco su camino hasta el nodo final, si es nodo final, me guardo su camino y su coste.

Sino, salgo del bucle, y lo desecho.

El array_visitados, y array_solucion es igual o menor a número de nodos.
Los demás son de Número de nodos x número de nodos.

Usuarios habituales