Nuevo Blog!

Publicado: octubre 19, 2012 en Uncategorized

Amigos mi nuevo blog es: http://elframeworkdeluis.wordpress.com/

Anuncios

Tutorial de 3ds Max Studio 2009

Publicado: noviembre 18, 2010 en Uncategorized

Este tutorial hecho por el Ing. Jorge Cruz Salazar de la materia de Graficacion explica como usar las figuras y herramientas basicas para diseñar cosas como una silla, una mesa, una banca, aplicar materiales, medidas, etc.

Para descargarlo, den click en el link y cuando cargue la pagina. dan click en “Click here to start download”

Descargalo aqui


Servidor apache


 

.model small
.stack
.data
mensaje1 db 'Programa para Introducir datos','$'
mensaje2 db '1.¿Cual es tu nombre?: ','$'
mensaje3 db '2.¿Cual es tu edad?: ','$'
mensaje4 db '3.¿Te gusta la materia?: ','$'
mensaje5 db '4.¿Te gusta programar en ensamblador?: ','$'
mensaje6 db '5.¿Copiaste la Tarea?: ','$'
cadena1 db 30 dup(' ')
cadena2 db 04 dup(' ')
cadena3 db 10 dup(' ')
cadena4 db 10 dup(' ')
cadena5 db 10 dup(' ')
namepar label byte
maxlen   db    20
actlen   db    ?
namefld  db	20 dup(' ')
.code
iniciar:
mov ax,@data
mov ds,ax
;------------------------crear una pantalla
mov ax,0600h
mov bh,71h
mov cx,0000h
mov dx,184fh
int 10h
;------------------------mensaje inicial
;--------fijar el cursor
mov ah,02h
mov bh,00
mov dh,00
mov dl,20
int 10h
mov ah,09h
lea dx,mensaje1
int 21h
;-----------------------primera pregunta
;-------------fijar el cursor
mov ah,02h
mov bh,00
mov dh,03
mov dl,00
int 10h
mov ah,09h
lea dx,mensaje2
int 21h
;----------pausa
mov ah,08h
int 21h
;---------capturar cadena
mov ah,3fh
mov bx,00
mov cx,30 ;defines la longitud de la cadena
lea dx,cadena1 ; donde la guardaras
int 21h
;-------------------------termina primera pregunta
;-------------------------escribes la cadena en pantalla
;-------------fijas el cursor de nuevo
mov ah,02h
mov bh,00
mov dh,05
mov dl,00
int 10h
;---------escribir la cadena
;mov ah,40h
;mov bx,01
;mov cx,30
;lea dx,cadena1
;int 21h
mov ah,02h		;servicio para mostrar un caracter
mov cx,30		;longitud de la cadena
lea di,cadena1		;direccion de la cadena
repetir: mov dl,[di]	;caracter que se despliega
int 21h			;llama a dos
inc di			;incrementa para el siguiente caracter
loop repetir		;si aun no termina repide el ciclo
;-----------------------segunda pregunta
;-------------fijar el cursor
mov ah,02h
mov bh,00
mov dh,07
mov dl,00
int 10h
mov ah,09h
lea dx,mensaje3
int 21h
;----------pausa
mov ah,08h
int 21h
;---------capturar cadena
mov ah,3fh
mov bx,00
mov cx,04 ;defines la longitud de la cadena
lea dx,cadena2 ; donde la guardaras
int 21h
;-------------------------termina segunda pregunta
;-------------------------escribes la cadena en pantalla
;-------------fijas el cursor de nuevo
mov ah,02h
mov bh,00
mov dh,09
mov dl,00
int 10h
;---------escribir la cadena
;mov ah,40h
;mov bx,01
;mov cx,04
;lea dx,cadena1
;int 21h
mov ah,02h
mov cx,04
lea di,cadena2
repetir1: mov dl,[di]
int 21h
inc di
loop repetir1
;-----------------------tercera pregunta
;-------------fijar el cursor
mov ah,02h
mov bh,00
mov dh,11
mov dl,00
int 10h
mov ah,09h
lea dx,mensaje4
int 21h
;----------pausa
mov ah,08h
int 21h
;---------capturar cadena
mov ah,3fh
mov bx,00
mov cx,10 ;defines la longitud de la cadena
lea dx,cadena3 ; donde la guardaras
int 21h
;-------------------------termina tercera pregunta
;-------------------------escribes la cadena en pantalla
;-------------fijas el cursor de nuevo
mov ah,02h
mov bh,00
mov dh,13
mov dl,00
int 10h
;---------escribir la cadena
;mov ah,40h
;mov bx,01
;mov cx,04
;lea dx,cadena1
;int 21h
mov ah,02h
mov cx,10
lea di,cadena3
repetir2: mov dl,[di]
int 21h
inc di
loop repetir2
;-----------------------cuarta pregunta
;-------------fijar el cursor
mov ah,02h
mov bh,00
mov dh,15
mov dl,00
int 10h
mov ah,09h
lea dx,mensaje5
int 21h
;----------pausa
mov ah,08h
int 21h
;---------capturar cadena
mov ah,3fh
mov bx,00
mov cx,10 ;defines la longitud de la cadena
lea dx,cadena4 ; donde la guardaras
int 21h
;-------------------------termina cuarta pregunta
;-------------------------escribes la cadena en pantalla
;-------------fijas el cursor de nuevo
mov ah,02h
mov bh,00
mov dh,17
mov dl,00
int 10h
;---------escribir la cadena
;mov ah,40h
;mov bx,01
;mov cx,04
;lea dx,cadena1
;int 21h
mov ah,02h
mov cx,10
lea di,cadena4
repetir3: mov dl,[di]
int 21h
inc di
loop repetir3
;-----------------------quinta pregunta
;-------------fijar el cursor
mov ah,02h
mov bh,00
mov dh,19
mov dl,00
int 10h
mov ah,09h
lea dx,mensaje6
int 21h
;----------pausa
mov ah,08h
int 21h
;---------capturar cadena
mov ah,3fh
mov bx,00
mov cx,10 ;defines la longitud de la cadena
lea dx,cadena5 ; donde la guardaras
int 21h
;-------------------------termina quinta pregunta
;-------------------------escribes la cadena en pantalla
;-------------fijas el cursor de nuevo
mov ah,02h
mov bh,00
mov dh,21
mov dl,00
int 10h
;---------escribir la cadena
;mov ah,40h
;mov bx,01
;mov cx,04
;lea dx,cadena1
;int 21h
mov ah,02h
mov cx,10
lea di,cadena5
repetir4: mov dl,[di]
int 21h
inc di
loop repetir4
;-----------------------------salir
mov ax,4c00h
int 21h

end iniciar

Aqui dejo mi manual hecho para la materia de servicios de red. con el cual monté un servidor ftp con ayuda de vsftpd. admite conexiones anonimas y usuarios virtuales. todo fue hecho en una maquina virtual y probada en otra maquina virtual con windows xp.  en la parte inferior descargan el documento despues de registrarse en sribd. saludos

Descarga:

Manual ftp

Clases parciales en C#.NET

Publicado: octubre 10, 2010 en C# .Net

Una clase puede contener un numero de procedimientos, áreas y constructores, asi como también otros objetos. Una clase funcional elevademente puede convertirse en bastante larga. Con C#, puede dividir el código origen para una clase en archivos separados, así puede organizar la definición de una clase grande en partes más pequeñas y fáciles de administrar. Esta característica se utiliza por Microsoft Visual Studio 2008 para aplicaciones WPF (Windows Presentation Foundation), donde el código de origen que el desarrollador puede editar se mantiene en archivos separados del código que se genera por Visual Studio en cualquier momento que el esquema de un formulario cambie.

Cuando divida una clase a través de archivos múltiples, definirá las partes de la clase utilizando la palabra clave partial en cada archivo. Por ejemplo si la clase Circle se divide entre dos archivos llamados circ1.cs (conteniendo los constructores) y circ2.cs (conteniendo los procedimientos y áreas), los contenidos de circ1.cs se parecerán a esto:

partial class Circle
{
public Circle() // Default constructor
{
radius=0;
}
public Circle(int initialRadius) // overloaded constructor
{
radius= initialRadius;
}
}

Los contenidos de circ2.cs se parecerán a estos:


partial class Circle
{
public double Area()
{
return Math.PI * radius * radius;
}
private int radius;
}

cuando compile una clase que se ha dividido en archivos separados, debe proporcionar todos los archivos al compilador.

Espero que que les sea de ayuda estos pequeños ejemplos. seguire poniendo mas de C# conforme aprenda :).


Informacion sobre este algoritmo y un ejemplo.

Normalmente, cuando se usa el algoritmo de planificación mediante colas multinivel, los proce­sos se asignan de forma permanente a una cola cuando entran en el sistema. Por ejemplo, si hay colas diferentes para los procesos de primer y segundo plano, los procesos no se mueven de una cola a otra, dado que no pueden cambiar su naturaleza de proceso de primer o segundo plano. Esta configuración presenta la ventaja de una baja carga de trabajo de planificación, pero resulta poco flexible.

Por el contrario, el algoritmo de planificación mediante colas multinivel realimentadas per­mite mover un proceso de una cola a otra. La idea es separar los procesos en función de las carac­terísticas de sus ráfagas de CPU. Si un proceso utiliza demasiado tiempo de CPU, se pasa a una cola de prioridad más baja. Este esquema deja los procesos limitados por E/S y los procesos interacti­vos en las colas de prioridad más alta. Además, un proceso que esté esperando demasiado tiem­po en una cola de baja prioridad puede pasarse a una cola de prioridad más alta. Este mecanismo de envejecimiento evita el bloqueo indefinido.

Por ejemplo, considere un planificador de colas multinivel realimentadas con tres colas, nume­radas de 0 a 2 (Figura 5.7). En primer lugar, el planificador ejecuta todos los procesos de la cola 0. Sólo cuando la cola 0 esté vacía ejecutará procesos de la cola 1. De forma similar, los procesos de la cola 2 solo se ejecutarán si las colas 0 y 1 están vacías. Un proceso que llegue a la cola 1 desalo­jará a un proceso de la cola 2 y ese proceso de la cola 1 será, a su vez, desalojado por un proceso que llegue a la cola 0.

Un proceso que entre en la cola de procesos preparados se coloca en la cola 0 y a cada uno de los procesos de esa cola se le proporciona un cuanto de tiempo de 8 milisegundos. Si el proceso no termina en ese tiempo, se pasa al final de la cola 1. Si la cola 0 está vacía, al proceso que se encuentra al principio de la cola 1 se le asigna un cuanto de 16 milisegundos. Si no se completa en ese tiempo, se lo desaloja y se lo incluye en la cola 2. Los procesos de la cola 2 se ejecutan basán­dose en una planificación FCFS, pero sólo cuando las colas 0 y 1 están vacías.

Este algoritmo de planificación proporciona la prioridad más alta a todo proceso que tenga una ráfaga de CPU de 8 milisegundos o menos. Tales procesos acceden rápidamente a la CPU, conclu­yen su ráfaga de CPU y pasan a su siguiente ráfaga de E/S. Los procesos que necesitan más de 8 milisegundos y menos de 24 milisegundos también son servidor rápidamente, aunque con una prioridad más baja que los procesos más cortos. Los procesos largos terminan yendo automática­mente a la cola 2 y se sirven, siguiendo el orden FCFS, con los cíelos de CPU no utilizados por las colas 0 y 1.

En general, un planificador mediante colas multinivel realimentadas se define mediante los parámetros siguientes:

•    El número de colas.

•    El método usado para determinar cuándo pasar un proceso a una cola de prioridad más alta.

•    El método usado para determinar cuándo pasar un proceso a una cola de prioridad más baja.

•    El método usado para determinar en qué cola se introducirá un proceso cuando haya que darle servicio.

La definición del planificador mediante colas multinivel realimentadas le convierte en el algo­ritmo de planificación de la CPU más general. Puede configurarse este algoritmo para adaptarlo a cualquier sistema específico que se quiera diseñar. Lamentablemente, también es el algoritmo más complejo, puesto que definir el mejor planificador requiere disponer de algún mecanismo para seleccionar los valores de todos los parámetros.

Diapositvas con la informacion.