Gramáticas de Libre Contexto y Autómatas de Pila

Vamos a demostrar ahora que ambos mecanismos, GLCs y APs, son equivalentes para denotar lenguajes libres del contexto. Comenzaremos con la conversión más sencilla.

La idea de AP(G) es que mantiene en la pila lo que aún espera leer. Esto está expresado como una secuencia de terminales y no terminales. Los terminales deben verse tal como aparecen, y “ver” un no terminal significa ver cualquier cadena de terminales que se pueda derivar de ´el. Por ello comienza indicando que espera ver S, cancela un terminal de la entrada con el que espera ver seg´un la pila, y puede cambiar un no terminal del tope de la pila usando cualquier regla de derivación. Nótese que basta un AP de dos estados para simular cualquier GLC. Esto indica que los estados no son la parte importante de la memoria de un AP, sino su pila.

Ejemplo 3.14 Dibujemos ap(G) para la GLC del Ej. 3.1. El AP resultante es bastante distinto de los que mostramos en el Ej. 3.9.

También es ahora muy fácil generar el AP para la GLC del Ej. 3.5, lo cual originalmente no era nada sencillo.

Obtener el AP de una GLC es el primer paso para poder hacer el parsing de un lenguaje LC. Demostraremos ahora que esta construcción es correcta.


Java Custom Tags Library

Problemas con JSPs:

JavaBeans nos permiten separar la parte de presentación de una página JSP de la implementación de una regla de negocio.
Sin embargo, sólo 3 elementos acción en JSP se pueden usar para acceder a un bean:
  • jsp:useBean
  • jsp:getProperty
  • jsp:setProperty
Por tanto a menudo tenemos que incluir código en un JSP.
JSP (1.1 en adelante) define Custom Tags Libs que pueden ser usadas para definir acciones propietarias, de manera que en nuestro JSP únicamente tenemos código de marcado.
Custom tags (etiquetas personalizadas) tienen acceso a todos los objetos disponibles en una JSP.
  • Pueden ser personalizadas usando atributos.
  • Como los JavaBeans se centran en reusabilidad de código.
  • Los custom tags son extensiones de JSP definidas por el usuario.
Las librerías de etiquetas personalizadas son:
  • Creadas por programadores, expertos en acceder a datos y servicios, y son
  • Usadas por Diseñadores de aplicaciones web especialistas en presentación.


Renta Fija

Valor Presente de una Deuda.

Supuestos:
–No existe la posibilidad de no pago (default)
–Flujos de caja son nominales
Las fórmulas tradicionales de valor presente aplican a la deuda:
Ejemplo: suponga que todas las tasas spot son iguales a 3.5% por cada 6 meses (cotizada a 7% anual). Los cupones son de 8% anuales y faltan 10 años para vencimiento.
Precio de un bono Cero Cupón con valor cara F y vencimiento en n años:
Precio de un bono Bullet que paga un cupón C, valor cara F y vencimiento en n años:
Precio de un bono Amortizable con cupones idénticos e iguales a C y vencimiento en n años:
Típicamente, para instrumentos de renta fija se define una rentabilidad promedio o yield-to-maturity y (que corresponde a una tasa constante o promedio de descuento).
Para un bono con maturity de n años, una frecuencia de pagos f, cupones C con respecto a su valor cara de $100 y precio P se define la yield-to-maturity y como:
Además, definimos la current yield como:

Current yield = Cupón Anualizado / Precio en Porcentaje


Tarea 1

admin.h

 

typedef struct Administrador {
	nMonitor mon;
	int *ocupado;
	int *visor;
	int *ticket;
	int n;
}
  *Administrador;

Administrador nuevoAdministrador(int n);
void pedir(Administrador adm, int recs[], int k);
void devolver(Administrador adm, int recs[], int k);


admin.c

#include "nSystem.h"
#include "admin.h"

Administrador nuevoAdministrador(int n) { 
	int i;
	Administrador adm= (Administrador)nMalloc(sizeof(*adm));
	adm->mon=nMakeMonitor();
	adm->ocupado=(int*)nMalloc(n*sizeof(int));
	adm->visor=(int*)nMalloc(n*sizeof(int));
	adm->ticket=(int*)nMalloc(n*sizeof(int));
	adm->n=n;

	for(i=0;i<n;i++){
		adm->ocupado[i]=0;
		adm->visor[i]=0;
		adm->ticket[i]=1;
	}
	return adm;
}

void pedir(Administrador adm, int recs[], int k) { 
	int i,mi_turno;
	int mi_ticket[adm->n];

	for(i=0;i<adm->n;i++)
		mi_ticket[i]=-1;

	mi_turno=0;

	nEnter(adm->mon);

	for(i=0;i<k;i++){
		/*si el recurso esta desocupado, el ticket es el visor*/
		if(adm->ocupado[recs[i]]==0){
			mi_ticket[recs[i]]=adm->visor[recs[i]];
		}
		/*si esta ocupado, le doy el ticket respectivo */
		else{
			mi_ticket[recs[i]]=adm->ticket[recs[i]]++;
		}
	}	

	for(i=0;i<k;i++)
		adm->ocupado[recs[i]]++;

	while(!mi_turno){
		mi_turno=1;
		for(i=0;i<k;i++){
			/*si mis tickets son distintos a los visores, no es mi turno */
			if(mi_ticket[recs[i]]!=adm->visor[recs[i]])
				mi_turno=0;
		}
		if(mi_turno!=1)
			nWait(adm->mon);
	}
	nNotifyAll(adm->mon);
	nExit(adm->mon);
}

void devolver(Administrador adm, int recs[], int k) {
	int i;	
	nEnter(adm->mon);	
	for(i=0; i<k;i++){
		adm->ocupado[recs[i]]--;
		/*si hay alguien esperando el recurso, aumento su visor*/
		if(adm->ocupado[recs[i]]>0)
			adm->visor[recs[i]]++;
	}
	nNotifyAll(adm->mon);
	nExit(adm->mon);
}



Capa Física

Contenidos:
  1. Bases Teóricas de la Comunicación Digital
  2. Modulación Digital
  3. Multiplexión
  4. Medios Físicos
  5. Medios No Guiados
1.- Bases Teóricas de la Comunicación Digital:
  • Ventajas de la Digitalización:
  • Menor vulnerabilidad al ruido por parte de las señales digitalizadas.
  • Facilidad para medir rendimiento y tasas de error.
  • Capacidad de aplicar métodos de corrección de errores o recuperación de la señal.
  • Desventajas de la Digitalización:
  • El procesamiento digital tiene implícito un retardo.
  • La conversión A/D y D/A introduce ruido de Cuantización.
  • Necesita sincronización.
  • Incompatibilidad con sistemas analógicos.


Lector-Escritor

lector:
consulta(…){

     enterRead();
     …
     exitRead();
}

escritor:

modificacion(…){
     
     enterWrite();
     …
     exitWrite();
}
-Lectura en paralelo
-escritura en exclusión mutura con otras lect. o escrit.
Sol con monitores

nMonitor c; /*=nMakeMonitor*/

int readers=0;
int writing=False;

void enterRead(){
     nEnter(c);
     while(writing)
          [nWait(c);]
     reader++;
     nExit(c);
}

void exitRead(){
     nEnter(c);
     reader–;
     [nNotifyAll(c);]
     nExit(c);
}

void enterWrite(){
     nEnter(c);
     while(readers>0||writing)
          [nWait(c);]
     writing=TRUE;
     nExit(c);
}

void exitWrite(){
     nEnter(c)
     writing=FALSE;
     [nNotifyAll(c);]
     nExit(c);
}
- Nunca hacer busy-waiting pq es ineficiente y si se hace mientras esta tomado un monitor, nunca se va a liberar (deadlock)

Fairness(justicia): ausencia de hambruna
Estrategia para lograr soluciones “fair” (justa)
enterWrite enterWrite enterWrite (Pendiente) enterWrite
No puede entrar ninguno que sigue si uno queda pendiente
Estrategia: Autorizar entradas en orden FIFO (First In First Out)
- Metáfora de la Isapre
nMonitor c; /*=nMakeMonitor*/

int readers=0;
int writing=False;
int visor=0; dist=0;

void enterRead(){
     int miturno;
     nEnter(c);
     miturno=dist++;
     while(writing||visor!=miturno)
          nWait(c);
     readers++;
     visor++; nNotifyAll(c);
     nExit(c);
}

void exitRead(){
     nEnter(c);
     reader–;
     nNotifyAll(c);
     nExit(c);
}

void enterWrite(){
     int miturno;
     nEnter(c);
     miturno =dist++
     while(writing || readers>0 ||visor!=miturno)
          nWait(c);
     writing=TRUE;
     visor++; nNotifyAll(c); (no es estrictamente necesario este notify all)
     nExit(c);
}

void exitWrite(){
     nEnter(c)
     writing=FALSE;
     nNotifyAll(c);
     nExit(c);
}
-Solucion eficiente eliminando los writing de los read
-Ejercios resueltos en el apunte en la pagina del profe
-Controles sin apuntes, con torpedo de una pagina
Ejercicio: Implementar un semáforo a partir de monitores.
- No necesariamente FIFO
- Que sea FIFO

Seguir

Recibe cada nueva publicación en tu buzón de correo electrónico.