/**
 * Clase que genera una base de datos con las frecuencias de todas las notas
 * musicales dentro de un rango de octavas.
 * Alguna frecuencias son:
 *
 * <table border=0>
 * <tr><th>  Nota   </th><th>octava1</th><th>octava2</th><th>octava3</th></tr>
 * <tr><td>C  / Do  </td><td>130.813</td><td>261.626</td><td>523.251</td></tr>
 * <tr><td>C# / Do# </td><td>138.591</td><td>277.183</td><td>554.365</td></tr>
 * <tr><td>D  /	Re  </td><td>146.832</td><td>293.665</td><td>587.330</td></tr>
 * <tr><td>D# /	Re# </td><td>155.563</td><td>311.127</td><td>622.254</td></tr>
 * <tr><td>E  /	Mi  </td><td>164.814</td><td>329.628</td><td>659.255</td></tr>
 * <tr><td>F  / Fa  </td><td>174.614</td><td>349.228</td><td>698.456</td></tr>
 * <tr><td>F# / Fa# </td><td>184.997</td><td>369.994</td><td>739.989</td></tr>
 * <tr><td>G  / Sol </td><td>195.998</td><td>391.995</td><td>783.991</td></tr>
 * <tr><td>G# / Sol#</td><td>207.652</td><td>415.305</td><td>830.609</td></tr>
 * <tr><td>A  / La  </td><td>220.000</td><td>440.000</td><td>880.000</td></tr>
 * <tr><td>A# / La# </td><td>233.082</td><td>466.164</td><td>932.328</td></tr>
 * <tr><td>B  / Si  </td><td>246.942</td><td>493.883</td><td>997.767</td></tr>
 * </table>
 * @author Daniel Acevedo, Francisco Barros.
 * @version v1.0
 */
public class Notas
	{
	float[][] Frec;
	String[] nombres = {"C","C#","D","D#","E","F","F#","G","G#","A","A#","B"};
	int nNumOctavas = 5;
	float factor = 1.0594630943592952645618252949461F;
	private boolean DEBUG = false;
    /**
     * Constructor de la clase Notas. Crea una matriz con 12 columnas
     * correspondiente a cada una de las 12 notas musicales. y el numero de
     * filas es según la variable nNumOctavas.
     */
	public Notas() // constructor
		{
		if(DEBUG) System.out.println("Nota.creando: comenzando");
		Frec = new float[nNumOctavas][12];
		afinar(0);
		if(DEBUG) System.out.println("Nota.creando: finalizado");
		}
    /**
     * Metodo que llena la matriz con la frecuencia de cada nota. El llenado de
     * las notas es primero en la primera octava. Partiendo por el La = 110 Hz +
     * delta. se van obteniendo las otras nota multiplicando o dividiendo por
     * factor segun corresponda. multiplicando se obtiene una nota mas aguda y
     * dividiendo por factor se obtiene una mas grave.
     * @param delta Parámetro que ajusta cuantos Hz se desviara (hacia arriba
     * o abajo) respecto del LA de 110 Hz.
     */
	public void afinar(int delta)
		{
		if(DEBUG)System.out.println("Nota.afinar: comenzando");
		Frec[0][9] = 110.000F + (float)(delta / 4);
		if(DEBUG) System.out.println("Nota.Frec[0][9]: " + Frec[0][9]);
		// llenado primera octava
		for(int j=8;j>=0;j--)
			{
			Frec[0][j] = Frec[0][j+1] / factor;
			if(DEBUG)
				{
				System.out.println("Nota.Frec[0]["+(j+1)+"]: " + Frec[0][j+1]);
				System.out.println("divisor: " + factor );
				System.out.println("Resultado: " + (Frec[0][j+1] / (float)Math.pow(2,(float)(1/12))) );
				}
			}
		for(int j=10;j<12;j++)
			Frec[0][j] = Frec[0][j-1] * factor; // hacia arriba: A# y B
		// para el resto de las octavas
		for(int i=1;i<nNumOctavas;i++)
			for(int j=0;j<12;j++)
				Frec[i][j] = Frec[i-1][j] * 2;
		if(DEBUG)
			System.out.println("Nota.afinar: finalizado");
		}
    /**
     * Metodo que rescata la frecuencia de una nota en una octava especifica.
     * @param nombre Nombre de la nota en clave americana. Por Ejemplo C, F#.
     * @param octava Octava de la nota. La primera octava es 0 y puede llegar
     * hasta nNumOctavas.
     * @return retorna la frecuencia de la nota solicitada.
     */
	public float get(String nombre,int octava)
		{
		if(nombre.equals("C"))
			for(int i=0;i<nNumOctavas;i++)
				if(i==octava)
					return Frec[octava][0];
		if(nombre.equals("C#"))
			for(int i=0;i<nNumOctavas;i++)
				if(i==octava)
					return Frec[octava][1];
		if(nombre.equals("D"))
			for(int i=0;i<nNumOctavas;i++)
				if(i==octava)
					return Frec[octava][2];
		if(nombre.equals("D#"))
			for(int i=0;i<nNumOctavas;i++)
				if(i==octava)
					return Frec[octava][3];
		if(nombre.equals("E"))
			for(int i=0;i<nNumOctavas;i++)
				if(i==octava)
					return Frec[octava][4];
		if(nombre.equals("F"))
			for(int i=0;i<nNumOctavas;i++)
				if(i==octava)
					return Frec[octava][5];
		if(nombre.equals("F#"))
			for(int i=0;i<nNumOctavas;i++)
				if(i==octava)
					return Frec[octava][6];
		if(nombre.equals("G"))
			for(int i=0;i<nNumOctavas;i++)
				if(i==octava)
					return Frec[octava][7];
		if(nombre.equals("G#"))
			for(int i=0;i<nNumOctavas;i++)
				if(i==octava)
					return Frec[octava][8];
		if(nombre.equals("A"))
			for(int i=0;i<nNumOctavas;i++)
				if(i==octava)
					return Frec[octava][9];
		if(nombre.equals("A#"))
			for(int i=0;i<nNumOctavas;i++)
				if(i==octava)
					return Frec[octava][10];
		if(nombre.equals("B"))
			for(int i=0;i<nNumOctavas;i++)
				if(i==octava)
					return Frec[octava][11];
		// else:
		return 1.0F;
		}
    /**
     * Metodo que imprime la matriz completa de frecuencias.
     */
	public void imprime()
		{
		imprime(0,nNumOctavas-1);
		}
    /**
     * Metodo que imprime una parte de la matriz de frecuencias entre dos
     * octavas especificadas en el llamado.
     * @param octInf Octava inferior.
     * @param octSup Octava Superior.
     */
	public void imprime(int octInf, int octSup)
		{
		int i,j;
		if(DEBUG) System.out.println("Nota.imprime: comenzando");
		if(octSup>nNumOctavas-1)
			octSup=nNumOctavas-1;
		for(i=octInf; i<=octSup; i++)
			{
			for(j=0;j<12;j++)
            System.out.printf(nombres[j]+ i + " = " + Frec[i][j] + ", ");
			System.out.printf("\n");
			}
		if(DEBUG) System.out.println("Nota.imprime: finalizado");
		}
	}