Algoritmos para detección del pitch

Esta investigación fue desarrollada para el curso de Tópicos en Ciencia de la Computación III (el semestre 2007-II), con tema: Reconocimiento Automático del Habla, y dictado por el profesor Jorge Guevara

Resumen:

El análisis del pitch es un área extensa de investigación, y es un factor muy utilizado en el análisis y síntesis del habla;
Esta investigación se enfoca en los distintos métodos existentes para la detección del pitch, los cuales se categorizan en función del dominio del tiempo y de la frecuencia.
El propósito de este proyecto es el de encontrar un método de detección de la frecuencia fundamental con buenas características, de manera que presente un desenvolvimiento eficiente/óptimo. Se plantean las ventajas y desventajas de cada método analizado, y se hará una implementación para llevar a cabo la comparación de los resultados según su desempeño (considerando tiempo de procesamiento, costo computacional, y los resultados obtenidos).


El paper y el programa pueden ser descargados de aquí!
(link roto, mientras busco servidor donde colgarlos!!)

La paridad del cero (0)

Mi pregunta en concreto es: el cero es un número par?
porque, si cero dividido entre cualquier otro número es cero.
Y la propiedad de la paridad (usando la función de modularidad %) es:
Un número es par si su residuo con 2, es cero:
n % 2 == 0 ; entonces n es par.
entonces... es par, o es indeterminado? (Cómo algún profesor matemático me enseñó)
Según Java:

public static void main(String[] ar) 
{ 
    int a=0,b=2; 
    double r; 
    r=Math.IEEEremainder(a,b); 
    System.out.println(r); 
}  

obtenemos que r = 0.0
---------------------------------------------------------------------------------

Particularmente, pretendo implementar un árbol rojo-negro (red-black tree), donde, además de ciertas características como el ser binario, y ser balanceado... utiliza colores (el rojo y el negro) para distinguir cada nivel.

entonces... Al balancear el árbol, para no complicarlo (más de lo que ya es)
mejor, al realizar los cambios, le resto (o le sumo) un 1 ...
Así, siempre que el color sea par, representará al color negro (niveles pares)
cuando el color sea impar, representa al rojo (niveles impares)

Pero (entonces) ...
el cero es un número par?

Invito a los visitantes a responder este dilema :)

Informática Teórica: Problema de Maximum Triangle Packing

Resumen
El presente trabajo abarca, dentro del área de investigación de Informática Teórica, el análisis y desarrollo de algoritmos, con su respectiva complejidad computacional de tiempo P o NP, y siendo aplicado a solucionar ciertos problemas de Teoría de Grafos;
Dentro de estos problemas, se le dará solución, concretamente, al algoritmo de grafos MTP:
Maximum Triangle Packing, o, su equivalente en español, Máximo Empaquetamiento de triángulos, donde el problema es, dado un grafo, si entre sus nodos forman algunos triángulos (grafos completos de 3 nodos), el algoritmo debe encontrar, bajo que orden se obtienen el mayor números de triángulos, siendo éstos, conjuntos disjuntos de nodos. Se planteará el algoritmo de solución, se presenta la implementación y estadísticas en base a algunas pruebas.

Para descargar el paper... clic aquí

Informática Teórica: Problema de Maximum Triangle Packing (Abstract)

Bienvenida?

A pesar de tener distintos websites a mi cargo (desde el hi5, el msn-live-space, mi cuenta en youtube, otro live-space, de mi página ~grgs en el servidor de la escuela de Informática-UNT, y esta página nato.gs q google me ofrece por mi cuenta de gmail...
Me atrevo a crear una página más, pero con nuevo contenido: académico, universitario =)
x eso mismo... esta es una bienvenida! ;)

Clase IU_Principal [Algoritmo de Booth]

IU_Principal.java:
Esta clase implementará los métodos de manejo de interfaces y eventos, para visualizar las operaciones del algoritmo de Booth de una manera visualmente más atractiva.
A continuación, el detalle de lo que se usó para implementarlo.


Atributos:

• private JButton btnCalcular;
  Es el botón con el cual se verifica que los datos ingresados sean correctos, y según eso, llama al algoritmo de Booth para calcular el resultado.
• private JButton btnLimpiar;
  Limpia los campos de texto para ingresar una nueva operación.
• private JTextArea txaOperaciones;
  Reporta paso a paso, las operaciones del algoritmo de Booth.
• private JTextField txtMultiplicando;
  Donde se ingresa el valor en base decimal del multiplicando de la operación.
• private JTextField txtMultiplicandoBin;
  Donde se reporta el multiplicando en binario.
• private JTextField txtMultiplicador;
  Donde se ingresa el valor en base decimal del multiplicador de la operación.
• private JTextField txtMultiplicadorBin;
  Donde se reporta el multiplicador en binario.
• private JTextField txtMultiplicacion;
  Donde se reporta a manera de cadena, la operación de forma: "a x b".
  
• private JTextField txtResultado;
  Donde se reporta el resultado de la operación, en base decimal.
  
• private JTextField txtResultadoBin;
  Donde se reporta el resultado de la operación en binario.
  

Además, también hay etiquetas JLabel y un par de JPanel.

Métodos:

• IU_Principal() : constructor
  Descripción: Inicializa todos los atributos, y ubicación en la interfaz de los elementos gráficos (Swing).
  Entrada: Cadena que representa un número en binario.
  Salida: Entero que representa el correspondiente valor en decimal.
  


• btnCalcularActionPerformed(java.awt.event.ActionEvent evt) : void
  Descripción: Convierte un número decimal, a un número binario.
  Entrada: evento a manejar.
  Salida: Vacío.


• btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) : void
  Descripción: Establece los valores de los cuadros de texto en vacío, limpiándolos para realizar un nuevo cálculo, y poniendo el foco (requestFocus) en el txtMultiplicando.
  Entrada: evento a manejar.
  Salida: Vacío.


• validarValoresEntrada() : boolean 
  Descripción: Verifica que los datos ingresados sean exclusivamente numéricos/enteros y no de ningún otro tipo. También verifica que (en este caso) sean menores de 256, para normalizar las cadenas de números binarios a 9 bits (8 normales + 1 bit de signo)
  Entrada: Vacío.
  Salida: Valor booleano, que indica si los datos ingresados son númericos/enteros, menores a 256 (verdadero) o no cumplen esas restricciones (devuelve falso).


• actualizarTextArea(String cadena) : void
  Descripción: Actualiza el JTextArea txaOperaciones, añadiendo (append) la cadena de entrada.
  Entrada: Cadena de texto a ser reportada dentro del textArea, siendo añadida en la última línea.
  Salida: Vacío.

Una imagen de cómo se ve la interfaz, con la disposición de ubicación de botones, tamaños, etc.
Los campos de texto deshabilitados, son los de tipo "reporte" para que el usuario no los pueda modificar.

Clase AlgoritmoBooth [Algoritmo de Booth]

AlgoritmoBooth.java:
Esta clase implementará todos los métodos propios del algoritmo de Booth, que no estén considerados en la clase OperacionesBinarias.java.

Algunos métodos se trabajarán por sobrecarga (overloading) para simplificar codificación.
Los métodos son estáticos porque depende de ningún atributo de la clase (los cuales no tiene)

• algoritmo(String multiplicando, String multiplicador) : String
  Descripción: Implementa el algoritmo de Booth, haciendo uso de todas las funciones previamente implementadas en la clase OperacionesBinarias para calcular el resultado correspondiente.
  Adicionalmente, muestra los datos, el procedimiento y operaciones, y el resultado en modo consola.
  Entrada: 2 cadenas representando números binarios.
  Salida: Cadena que representa el número binario del producto.
  
  
• algoritmo(int multiplicando, int multiplicador) : int
  Descripción: Recibe los datos a operar del tipo entero, los convierte en binario (cadenas), los normaliza (en tamaño), llama a String:algoritmo con esos valores, y el valor retornado, lo transforma a entero y lo devuelve.
  Entrada: 2 enteros, números a operar.
  Salida: Entero, valor del resultado de la operación (producto).
  
  
• algoritmo(IU_Principal interfaz, String multiplicando, String multiplicador) : String
  Descripción: Implementa el algoritmo de Booth, haciendo uso de todas las funciones implementadas en la clase OperacionesBinarias para calcular el resultado correspondiente.
  Adicionalmente, muestra los datos, el procedimiento y operaciones, y el resultado en modo consola, y utiliza el parámetro interfaz para actualizar el textArea donde reporta las operaciones del algoritmo.
  Entrada: 2 cadenas representando números binarios.
  Salida: Cadena que representa el número binario del producto.

Respecto al algoritmo principal, éste es el procedimiento:
Se le han suprimido los códigos de impresión, y formato de impresión para hacerlo legible, y enfocándome únicamente en el código del mismo algoritmo de Booth.

1. public static String algoritmo(String multiplicando, String multiplicador)
2. {
3. String resultado="";
4. String A=OperacionesBinarias.completarDerecha(multiplicando);
5. String S=OperacionesBinarias.complementoA2(multiplicando);
6. S=OperacionesBinarias.completarDerecha(S);
7. String P=OperacionesBinarias.completarIzquierda(multiplicador);
9. int i=0,n=multiplicando.length();
10. char ultimo, penultimo;
11. char cadena[]=new char[2*n];
12. for(i=0;i<n;i++)
13. {
14. ultimo=P.charAt(P.length()-1);
15. penultimo=P.charAt(P.length()-2);
17. if(penultimo=='0' && ultimo=='0')
18. {
19. // No realizar ninguna acción
20. }
21. else
22. {
23. if(penultimo=='0' && ultimo=='1')
24. {
25. // P termina en [0 1] -> P = P + A
26. P=OperacionesBinarias.suma(P, A);
27. }
28. else
29. if(penultimo=='1' && ultimo=='0')
30. {
31. // P termina en [1 0] -> P = P + S = P - A
32. P=OperacionesBinarias.suma(P, S);
33. }
34. else
35. {
36. // No realizar ninguna acción
37. }
38. }
40. P=OperacionesBinarias.desplazarDerecha(P);
41. }
43. for(i=0;i<2*n;i++)
44. {
45. cadena[i]=P.charAt(i);
46. }
48. resultado=String.valueOf(cadena);
49.  
50. // devuelve el resultado, quitandole el ULTIMO bit
51. return resultado;
52. }