Mensajes

[librería iText para Java]

Ya le estuve echando un ojo, el problema que trae es que, aparte de ser muy extensa, viene cuál es la estructura interna de un documento PDF pero no cómo manipular esa estructura. Finalmente, como he puesto en la última actualización del hilo, me he decantado por usar la librería iText para Java para hacerlo.

Si te gusta la manera exhaustiva... Leyendo esto puedes hacer eso y mucho mas

https://www.adobe.com/content/dam/acom/en/devnet/pdf/pdfs/PDF32000_2008.pdf

[almacenar de manera interna en un documento PDF pequeños datasets que luego puedan ser extraídos]

Estoy haciendo un proyecto y necesito almacenar de manera interna en un documento PDF pequeños datasets que luego puedan ser extraídos. Estos datos pueden ser de tipo entero, real, booleano y cadenas de texto. A nivel de guardado creo que PDF trae de manera básica arrays donde podría almacenar esos datos, pero me surgen dudas respecto a la extracción, sobre todo en cuanto a la identificación de esos datos.

¡Si alguien tiene alguna idea estaría muy agradecido de que la compartiera!

ACTUALIZACIÓN (07/04):
He visto que existen ciertos objetos internos en PDF que se llaman diccionarios y que a su vez podrían contener otros objetos de tipo array que pueden servir para mi propósito. El problema que tengo ahora es todo el tema de identificación del objeto, tanto al guardar como al extraer.

ACTUALIZACIÓN (16/04):
Finalmente he visto que es posible usar la librería iText para Java que permite manipular documentos PDF. Estoy guardando datos en el objeto PDF Catalog que viene de manera predeterminada en todos los documentos PDF para evitar problemas de identificación ya que mediante el uso de iText el acceso y modificación de este objeto PDF Catalog es trivial.

Buenas,

me ha surgido una dudilla haciendo un ejercicio básico de MPI, ¿al hacer un broadcast se espera confirmación de recepción por parte del resto procesos?

Código (c) [Seleccionar] Expandir


#include "mpi.h"
#include <stdio.h>
#include <stdlib.h>

int main (int argc, char *argv[]){
int numtasks, taskid, len, buffer, root, count;
char hostname[MPI_MAX_PROCESSOR_NAME];

MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
MPI_Comm_rank(MPI_COMM_WORLD,&taskid);
MPI_Get_processor_name(hostname, &len);

printf ("Task %d on %s starting...\n", taskid, hostname);
root = 0;
count = taskid;
if (taskid == root)
buffer = 23;
printf("Root: Number of MPI tasks is: %d\n", numtasks);

MPI_Bcast(&buffer, count, MPI_INT, root, MPI_COMM_WORLD);

printf("Buffer is %d from task %d\n", buffer, taskid);

MPI_Finalize();

}


La duda me ha surgido porque hay un error en él, que es que el tamaño de lo que se envía es igual al identificador del proceso que lo está ejecutando, y este error produce un interbloqueo. No entiendo por qué pasa esto. El broadcast como tal solo lo va a ejecutar el proceso maestro, así que para el código de arriba el count sería como un 0, lo que estaría mal. La cosa es que si meto un 0 a mano funciona y no entiendo por qué.

Código [Seleccionar] Expandir


MPI_Bcast(&buffer, 0, MPI_INT, root, MPI_COMM_WORLD);


Solo es en el caso de que count sea taskid, que como repito al ejecutar el maestro sería 0, cuando no funciona.

La única conclusión posible a la que he llegado es que el broadcast espera confirmación de recepción del envío por parte del resto de procesos y al no llegar a recibirlo se produce el interbloqueo, pero no lo sé.

¡Un saludito y gracias!

Muchas gracias, duda(s) resueltas

Hola, estoy intentando dar un valor a algunas posiciones de un array de chars y estoy teniendo un problema al final a la hora de devolverlo. Cuando le meto los valores se ve que lo está haciendo bien pero después, a la hora de imprimirlos, me devuelve, para cada posición que he escrito, el valor que le di al último. El código que llevo:

Código [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>

int main(int argc, char* argv[]){

int n = 0;
char line[80], input[80];
char *array[25];

for(;fgets(line, 80, stdin);){
       if(!strcmp(line, "Exit\n")){
    break;
       }

   //  Leer de la entrada estándar
   sscanf(line, "%s", input);
   array[n] = input;
   printf("%s\n", array[n]);
   n++;
}

for(int i=0; i<n; i++){
printf("%s\n", array[i]);
}
}


Para la siguiente ejecución:

Código [Seleccionar] Expandir


fileteruso@vbox-ubuntu:~/Escritorio/Pruebas$ ./prueba
ESTO
ESTO
ES
ES
UNA
UNA
PRUEBA
PRUEBA
Exit
PRUEBA
PRUEBA
PRUEBA
PRUEBA


Si alguien puede ayudarme le estaría muy agradecido.

Al final he conseguido que funcione. Por si a alguien más le interesa, era simplemente añadir un parámetro más que indique el número de instrucciones que se pueden ejecutar de forma que primero ejecuta todos los caminos posibles con una instrucción, después con dos, y así sucesivamente, encontrando siempre el número mínimo de instrucciones necesarias.

Debido a que no consigo el camino mínimo estoy intentando conseguir el primer camino que se encuentre.
Como bien dices la clave está en usar el backtracking de Prolog, la cosa es que para valores con 2 o 3 registros solo (regs(x,x) o regs(x,x,x)) funciona perfectamente: si encuentra un camino, lo devuelve, y si, después de recorrer todas la opciones recursivamente, no encuentra ningún camino que lleve al estado final, devuelve false y acaba. Sin embargo, para valores mayores ocurre que solo devuelve aquellos casos en los que se encuentra una solución en las primeras ramas recorridas. El código que he hecho hasta ahora es el siguiente:

Código [Seleccionar] Expandir


generar_codigo(EstadoInicial,EstadoFinal,ListaDeInstrucciones) :-
   functor(EstadoInicial,regs,NumCaracteres),
   functor(EstadoFinal,regs,NumCaracteres),
   ListaParcial = [no_instr],
   generar_codigo(EstadoInicial,EstadoFinal,ListaParcial,ListaInversa,NumCaracteres,[EstadoInicial]),
   reverse(ListaInversa,ListaDeInstrucciones).

generar_codigo(EstadoActual,EstadoActual,ListaParcial,ListaParcial,NumCaracteres,_) :- !.
generar_codigo(EstadoActual,EstadoFinal,ListaParcial,ListaDeInstrucciones,NumCaracteres,EstadosVisitados) :-
   get_cabeza(ListaParcial,InstrAnterior),
   instrs_posibles(EstadoActual,1,NumCaracteres,InstrAnterior,InstrAEjecutar),
   ejecutar_instruccion(EstadoActual,InstrAEjecutar,EstadoSig),
   \+ member(EstadoSig,EstadosVisitados),
   generar_codigo(EstadoSig,EstadoFinal,[InstrAEjecutar|ListaParcial],ListaDeInstrucciones,NumCaracteres,[EstadoSig|EstadosVisitados]).



get_cabeza(L,E) devuelve en E el primer elemento de la lista L y reverse(LI,LF) devuelve en LF la lista LI invertida.

El predicado instrs_posibles/5 devuelve una instrucción (InstrAEjecutar) que se puede realizar pasado un estado (EstadoActual) y si tras devolver esa solución se piden más devuelve el resto hasta que no encuentra más:

Código [Seleccionar] Expandir


?- instrs_posibles(regs(a,b,c),1,3,no_instr,Instr).

Instr = move(1) ? ;

Instr = swap(1,2) ? ;

Instr = swap(1,3) ? ;

Instr = move(2) ? ;

Instr = swap(2,3) ? ;

Instr = move(3) ? ;

false
?-



Lo que no llego a entender es por qué hay ocasiones en las cuales se queda en un bucle infinito, si, como he comentado antes, en los casos en los que hay 2 o 3 registros máximos acaba perfectamente y si los ejecuto con el debugger se ve claramente como recorre todas las opciones posibles.

Gracias de nuevo por la ayuda.

Buenos días,

tengo que hacer un programa como práctica para la universidad y no se me ocurre ninguna solución posible a priori, si alguien puede ayudarme le estaría muy agradecido.

Tengo que hacer en Prolog una representación de una CPU anular con registros. Los registros se representan de la siguiente forma: regs/n donde n es cualquier número mayor o igual que 2. Los registros pueden llevar en su interior cualquier tipo de carácter, un ejemplo:

Código [Seleccionar] Expandir


regs(a,b,c,d).


En la CPU hay 2 tipos de intrucciones swap/2 y move/1, y al ejecutarlas resulta lo siguiente:

Código [Seleccionar] Expandir


ejecutar_instruccion(regs(a,b,c,d),swap(1,3),R).
R = regs(c,b,a,d).

ejecutar_instruccion(regs(a,b,c,d),move(2),R).
R = regs(a,b,b,d).


Este predicado ya lo he hecho, ahora me piden realizar un generador de código que te lleve de un estado inicial a un final de la siguiente manera:

Código [Seleccionar] Expandir


generador_codigo(regs(a,b,c,d),regs(a,a,d,b),R).
R = [swap(2,3), move(1), swap(3,4)].


Resultando el número mínimo de instrucciones necesarias para alcanzar el estado final. No se me ocurre manera alguna de programarlo. Si alguien me pudiese ayudar y decirme algún algoritmo (no código como tal) que lo solucione le estaría muy agradecido.

Muchas gracias a todos de antemano.

Vale, ya he descubierto qué hay que hacer, lo dejo aquí por si a alguien más pudiera servirle:

Código (java) [Seleccionar] Expandir


JFrame frame = new JFrame();
JPanel panel = new JPanel();
frame.add(panel);
panel.addMouseListener(new MouseAdapter() {
    @Override
    public void mousePressed(MouseEvent e) {
        System.out.println(e.getX() + "," + e.getY());
    }
});
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(200, 200);
frame.setVisible(true);


Buenas,

necesito sacar las coordenadas de un JFrame al pulsar el ratón sobre algún punto del mismo. En internet he encontrado que es posible usar MouseListener, pero según he visto de los métodos que ofrece ninguno permite devolver las coordenadas dentro del JFrame, ¿alguna idea?

Muchas gracias de antemano.