Cerrado por Vacaciones

Metodo de Gauss- Jordan

fprintf('\n\n\n\t\t********************************************************************************\n')
fprintf('\t\t*   Este metodo es similar al de la eliminacion gaussiana, pero la             *\n')
fprintf('\t\t*   caracteristica importante de este metodo es que a diferencia de obtener    *\n')
fprintf('\t\t*   el valor de las variables del sistema en forma regresiva, aqui se los      *\n')
fprintf('\t\t*   obtiene directamente de reducir por filas la matriz aumentada A|B          *\n')
fprintf('\t\t********************************************************************************\n\n')


fprintf('\n\t\t********************************************************************************\n')
fprintf('\t\t*    Antes de empezar a ejecutar el algoritmo de Gauss-Jordan en el sistema,   *\n')
fprintf('\t\t*    por favor escoja una opcion de presentacion de datos....                  *\n')
fprintf('\t\t********************************************************************************\n\n\n')

fprintf('\t\t\t\t1. Format short; coma fija con 4 decimales (defecto)\n');
fprintf('\t\t\t\t2. Format long; coma fija con 15 decimales\n');
fprintf('\t\t\t\t3. Format short e;  notación científica con 4 decimales\n');
fprintf('\t\t\t\t4. Format long e;  notación científica con 15 decimales\n');
fprintf('\t\t\t\t5. Format rat;  expresa los números racionales como cocientes de enteros\n');



fprintf('\n\t\tIngrese una opcion por favor;\n');
onn=input('                Opcion #   ');
if (onn~=1&onn~=2&onn~=3&onn~=4&onn~=5)
    fprintf('\n\t\t\t\tIngrese una opcion valida...por favor, \n\n')
    fprintf('\n\t\t\t\tse iniciara con format short(por defecto) \n\n')
end

switch (onn) 
    
        case 1, 
            format short
            fprintf('\n\t\tLa presentacion de datos se va a iniciar segun\n ')
            fprintf('\n\t\tFormat short; coma fija con 4 decimales (defecto)\n')
        case 2, 
            format long
            fprintf('\n\t\tLa presentacion de datos se va a iniciar segun\n ')
            fprintf('\n\t\tFormat long; coma fija con 15 decimales\n')
        case 3, 
            format short e
            fprintf('\n\t\tLa presentacion de datos se va a iniciar segun\n ')
            fprintf('\n\t\tFormat short e;  notación científica con 4 decimales\n')
        case 4,
            format long e
            fprintf('\n\t\tLa presentacion de datos se va a iniciar segun\n ')
            fprintf('\n\t\tFormat long e;  notación científica con 15 decimales\n')
        case 5, 
            format rat
            fprintf('\n\t\tLa presentacion de datos se va a iniciar segun\n ')
            fprintf('\n\t\tFormat rat;  expresa los números racionales como cocientes de enteros\n')
end


fprintf('\n\t\tPresione una tecla para continuar por favor...\n ')
pause
clc
fprintf('\n\t\t\tIngrese la matriz de coeficientes  por favor\n\n')
fprintf('\t\t********************************************************************************\n')
fprintf('\t\t*                       POR EJEMPLO [4 1 2;2 4 -1;1 1 -3]                      *\n')
fprintf('\t\t********************************************************************************\n\n')

aa=input('                      ');

fprintf('\n\t\t\tIngrese matriz columna de terminos independientes  por favor\n\n')
fprintf('\t\t********************************************************************************\n')
fprintf('\t\t*                              POR EJEMPLO [9;-5;-9]                           *\n')
fprintf('\t\t********************************************************************************\n\n')
bb=input('                      ');

A=[aa,bb];
fprintf('\n\t\t\t\t\tLa matriz aumentada A|B del sistema es;\n')
A
fprintf('\n\n\t\t\t\tPresione una tecla para continuar por favor...'), pause
[m,n] = size(A);
i = 1;
j = 1;
k = 0;
tol = max([m,n])*eps*norm(A,'inf'); 
while (i <= m) & (j <= n)
   [p,k] = max(abs(A(i:m,j))); k = k+i-1;
   if (p <= tol)
      fprintf(['\n\n\t\t\t\t  Columna ' int2str(j) ' es insignificante'])
      A(i:m,j) = zeros(m-i+1,1)
      fprintf('\n\n\t\t\t\tPresione una tecla para continuar por favor...\n')
      pause
      j = j + 1;
   else
      if i ~= k
         % Cambiar las i-esimas y las k-esimas filas.
         fprintf(['\n\n\t\t\t\tCambiar filas ' int2str(i) ' y ' int2str(k) blanks(10)])
         fprintf('\n\n')
         A([i k],:) = A([k i],:)
         fprintf('\n\n\t\t\t\tPresione una tecla para continuar por favor...\n')
         pause
      end
      % Normaliza la i-esima fila%
      fprintf('\n\n\t\t\t\tEliminando columna %d\n',j)
      fprintf(['\n\t\t\t\ta partir de la referencia en A(' int2str(i) ',' int2str(j) ')' blanks(10)])
      fprintf('\n\n\t\t\t\tA(%d,%d)/%0.5f\n',i,j,A(i,j))
      A(i,j:n) = A(i,j:n)/A(i,j)
      fprintf('\n\t\t\t\tPresione una tecla para continuar por favor...\n')
      pause
      %Ejecuta la eliminacion de la j-esima columna a partir de la i-esima
      %fila%
      fprintf(['\n\n\t\t\t\tEliminando la columna ' int2str(j) blanks(10)])
      fprintf('\n')
      A
      fprintf('\n\n\t\t\t\tPresione una tecla para continuar por favor...\n')
      pause
      for k = 1:m
         if k ~= i
            fprintf('\n')
            fprintf('\n\n\tFila[%d]=Fila[%d] - (A[%d,%d]/A[%d,%d])*Fila[%d]\n',k,k,k,j,i,j,j)
            pause
            A(k,j:n) = A(k,j:n) - A(k,j)*A(i,j:n)
         end
      end
      fprintf('\n\n\t\t\t\tPresione una tecla para continuar por favor...\n')
      pause
      i = i + 1;
      j = j + 1;
   end
end

   fprintf('\n\n\t\t\t\tEntonces los valores de  las incognitas son;\n')
      for k = 1:m
            fprintf('\n\n\tx(%d)=%d\n',k,A(k,n))
            pause

Script que soluciona ecuaciones diferenciales y de diferencias.

ECUACIONES DIFERENCIALES EN FORMA SIMBÓLICA y(t)
con x(t) igual a las siguientes entradas; función impulso(d(t)-delta de dirac), función paso u(t), y función rampa t*u(t)mediante el uso de la Transformada de Fourier.

ECUACIONES DE DIFERENCIAS EN FORMA GRÁFICA Y SIMBÓLICA
muestra tres tipos de respuesta, impulso, paso y rampa, se ingresa los coeficientes de la ecuación y los coeficientes de larespuesta, presenta la solución en forma grafica usando stem, la transformada de fourier con plot(), y ademas la transformada z en forma simbólica.

Script that solves differential equations and differences.

Differential equations in symbolic form and (t)
with x (t) equal to the following entries; impulse function (d (t) the dirac-delta), step function u (t), and ramp function t * u (t) using Fourier Transform.

DIFFERENCES IN FORM EQUATIONS graphics and symbols
shows three types of response, impulse, step and ramp, enters the equation coefficients and coefficients of the answer, the solution presented in graphical form using stem, Fourier transform plot (), and also z-transform symbolic form  

DESCARGAR

Ordenación por inserción

Características.
• Es un algoritmo sencillo de entender y de codificar.
• Si el tamaño de la entrada es N, entonces el orden del tiempo de ejecución, para el
peor caso es O(N2);
• Si la entrada esta "casi ordenada", el algoritmo se ejecuta mucho más rápidamente.
Esta velocidad tiende a un tiempo O(N), peor caso que se cumple cuando la entrada
está totalmente ordenada.
• Es por la propiedad anterior que este algoritmo, a pesar de no ser el más rápido para
entradas grandes, suele usarse de la siguiente manera: Se semi ordena la entrada con
algún otro algoritmo más rápido y más adecuado para entradas grandes. Luego,
cuando tenemos la entrada "casi ordenada" usamos este algoritmo. La velocidad de
ejecución será muy buena por dos razones: su tiempo de ejecución tiende a O(N) con
entradas "casi ordenadas" (lo cual es un tiempo excelente), y la simpleza de su
implementación hará que se ejecute más rápido que otros algoritmos más complejos.
Esto se implementará en Section 8.
Explicación del algoritmo. Sea A el array a ordenar con N elementos. El algoritmo
consiste en recorrer todo el array A comenzando desde la posición p=2 y terminando en
p=N. Para cada p, se trata de ubicar en el lugar correcto el elemento A[p] en entre los
elementos anteriores: A[p-1], A[p-2], ..., A[0].
Dada la posición actual p, el algoritmo se basa en que los elementos A[0], A[1], ...,
A[p-1] ya están ordenados.

void
ordenacion_insercion (Dato * A, int N)
{
int p, j;
Dato tmp;
for (p = 1; p < N; p++)
{
tmp = A[p];
j = p - 1;
while ((j >= 0) && (tmp < A[j]))
{
A[j + 1] = A[j];
j--;
}
A[j + 1] = tmp;
}
}

Algoritmo de Ordenacion por Selección

Características.

• Su tiempo de ejecución es O(N2) para el mejor, peor y caso promedio.
• Es el más fácil de codificar de los mostrados en este documento.
• Si el array de datos es A y su tamaño es N, lo que hace el algoritmo, para cada i de
   [0..N-2] es intercambiar A[i] con el mínimo elemento del subarray [A[i+1], ...,
    A[N]].
• Dado que es muy simple de codificar, aunque no tiene los mejores tiempos de
  ejecución, es apropiado utilizarlo para arrays de datos relativamente pequeños.

Ejemplo 

void
intercambiar (Dato * A, int i, int j)
{
Dato tmp = A[i];
A[i] = A[j];
A[j] = tmp;
}
void
ordenacion_seleccion (Dato * A, int N)
{
int i, j, k;
for (i = 0; i < N - 1; i++)
{
for (k = i, j = i + 1; j < N; j++)
if (A[j] < A[k])
k = j;
if (k != i)
intercambiar (A, i, k);
}
}

Curso Presencial De Ruby Gratuito

 Curso Presencial de Ruby en la Cd. de México  Gratuito.

9 Julio, 2012 - 17:00 - 19:00

10 Julio, 2012 - 17:00 - 19:00

11 Julio, 2012 - 17:00 - 19:00

12 Julio, 2012 - 17:00 - 19:00 

Ruby es el lenguaje de programación que combina lo mejor de la orientación a objetos y la facilidad del scripting generando un lenguaje dinámico, muy expresivo, potente, muy fácil de aprender y que permite crear aplicaciones robustas, estables y seguras.

Requisitos:

Llevar laptop con LINUX o Windows, para que practiques.

Si no tienes una, TELMEXHUB te presta una -debes de registrarte-.

Vamos a usar las herramientas que trae el sistema operativo para editar, compilar y ejecutar. En este caso usaremos el IDE SublimeText y el intérprete de Ruby para Linux, Windows y Mac.

Si nunca has usado LINUX, hacemos una introducción rápida al uso de comandos en la consola.

Y sobre todo muchas ganas de aprender.

El taller va dirigido principalmente a usuarios que quieren iniciarse en la programación

El taller se desarrollará en base al siguiente temario:
Objetivos:
El principal objetivo del curso es el de brindar explicaciones simples, concretas y prácticas de cómo dar los primeros pasos en Ruby, guiando al participante para:

• Aprender a instalar el entorno de desarrollo y ejecución
• Entender los principios de Ruby y cómo se programa con este lenguaje
• Entender las clases de la librería más importantes

Temario:

Unidad 01: Introducción al lenguaje

• Principios del lenguaje de programación
• Historia del lenguaje
• Conceptos básicos de programación utilizando IRB

Unidad 02: Instalación del entorno de desarrollo

• Tipos de instalación
• Instalación sobre las diferentes plataformas (Windows, Linux y Mac)

Unidad 03: Primeros pasos con el lenguaje

• Primera aplicación “Hola Mundo”
• Arreglos y declaraciones
• Estructuras de control (if / ciclos / case / excepciones)

Unidad 04: Clases, Objetos y Variables

• Creando clases, herencias, métodos y módulos
• Objetos, atributos y visibilidad
• Manejo de bloques de código

Unidad 05: Librería de Ruby

• Números, Cadenas y expresiones
• Arreglos y Hash
• Manejo de archivos (I/O)

Lugar: Isabel La Católica 51, Centro, Cuauhtémoc, 06000 Ciudad de México, Distrito Federal, México

VideoTutorial 30 de MAtlab

Creación de menús y contex menús en Matlab, también veremos los comando Fullfile, Imwrite, UIgetfile, los cuales nos servirán para cargar datos a nuestra Interfaz, procesarlos y posterior mente guardarlos, usando la barra de menús y los menús contextuales.

VideoTutorial 30 de MAtlab from Isrant on Vimeo.