Armonización de la escala menor armónica

Objetivo: presentar los acordes que aparecen tras armonizar la escala menor armónica.

La escala menor armónica debe formar parte del bagaje de todo músico, al igual que, naturalmente, los acordes que surgen en su armonización.

El procedimiento que seguiremos para armonizarla es el mismo que ya hemos repetido en varias ocasiones: partiendo de las notas de la escala, agregaremos sobre cada grado terceras sucesivas y pondremos nombre a los acordes de tres y cuatro notas que nos aparecerán. Si en algún momento te parece que estoy yendo demasiado rápido, consulta, por favor, los artículos anteriores.

Menor armónica: 1 – 2 – b3 – 4 – 5 – b6 – 7

Si no tienes su sonido en la mente, toma tu instrumento y escucha su evocadora y característica melodía. Eso ayudará a crear ambiente y nos introducirá en materia. Percátate de la distancia de tres semitonos entre la b6 y la 7.

Con la fórmula ante nosotros, la escala Do menor armónica resulta obvia:

Do menor armónica: C – D – Eb – F – G – Ab – B

Apilemos terceras tomándolas de la misma escala:

C: C – Eb – G: tercera menor (3 semitonos) + tercera mayor (4 semitonos): tríada menor.

D: D – F – Ab: tercera menor + tercera menor: tríada disminuida.

Eb: Eb – G – B: tercera mayor + tercera mayor: tríada aumentada.

F: F – Ab – C: tercera menor + tercera mayor: tríada menor.

G: G – B – D: tercera mayor + tercera menor: tríada mayor.

Ab: Ab – C – Eb: tercera mayor + tercera menor: tríada mayor.

B: B – D – F: tercera menor + tercera menor: tríada disminuida.

Recopilemos las tríadas que hemos obtenido:

Cm – D° – Eb+ – Fm – G – Ab – B°

Para generalizar a cualquier otra tonalidad distinta de Do menor volvemos a hacer uso de la fórmula relativa, especificando esta vez los acordes deducidos:

Im – II° – bIII+ – IVm – V – bVI – VII°

Apilamos una tercera más y obtenemos las tétradas:

C: C – Eb – G – B
La forma más rápida de identificar estos acordes, conociendo ya la tríada sobre la que se sustentan, consiste en identificar qué tipo de séptima tenemos. Recordemos: la séptima es mayor si está a un semitono de la octava, menor si lo está a dos y disminuida si dista tres semitonos. En nuestro caso, B y C están a un semitono, luego la séptima es mayor. Como la tríada es menor, el acorde resultante es Do menor con séptima mayor, Cm(maj7).

D: D – F – Ab – C
Tríada disminuida con la séptima menor (C y D están a dos semitonos), de modo que estamos ante Dm7(b5) (también se conoce a este tipo de acorde como semidisminuido).

Eb: Eb – G – B – D
Tríada aumentada con séptima mayor: Eb+(maj7)

F: F – Ab – C – Eb
Tríada menor con séptima menor: Fm7

G: G – B – D – F
Tríada mayor con séptima menor: G7

Ab: Ab – C – Eb – G
Tríada mayor con séptima mayor: Abmaj7

B: B – D – F – Ab
Tríada disminuida con séptima disminuida (observa los tres semitonos entre Ab y B): el acorde disminuido completo, B°, también cifrado como Bdim7.

Recopilando:

Cm(maj7) – Dm7(b5) – Eb+(maj7) – Fm7 – G7 – Abmaj7 – B°

Generalizando:

Im(maj7) – IIm7(b5) – bIII+(maj7) – IVm7 – V7 – bVImaj7 – VII°

Demos la bienvenida al acorde disminuido completo en versión tétrada, que es la primera vez que aparece en nuestras armonizaciones.

Te dejo saludándole…

Javier Montero Gabarró


Armonización de la escala menor armónica


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Índice completo de artículos sobre armonía.

Java – Los ocho magníficos

lasecreObjetivo: presentar los tipos de datos primitivos en Java.

Antes de que empecemos a fabricar objetos como churros es importante que nos tomemos un tiempo para familiarizarnos con la materia prima de que están hechos, los ladrillos con los que construiremos nuestras nuevas estructuras de datos.

Sabemos que los objetos se componen de atributos, que no son más que un conjunto de variables con sus respectivos valores, y de métodos, las funciones que definen el comportamiento del objeto, lo que se puede hacer con él. Estos métodos, por lo general, procesan y devuelven datos también.

De modo que las variables son la sangre que circula internamente por los objetos.

Java requiere que especifiquemos el tipo de una variable en el momento preciso de declararla. Si recuerdas las clases Coche y Persona de los artículos anteriores, verás que aparecían en ellas algunas instrucciones como las siguientes:

String marca;
int velocidad;
boolean arrancado;
char sexo;
Coche coche;

Se trata de declaraciones de variables, en las que se asocia a cada nombre un tipo. Así pues, la variable marca referenciará una cadena de caracteres para indicar la marca del coche; velocidad contendrá un valor entero para expresar su velocidad; arrancado, de tipo booleano (verdadero o falso) nos hará saber si el vehículo está puesto en marcha o no; sexo contendrá un único carácter para indicar si la persona es un hombre o una mujer; coche, finalmente, es una variable de tipo Coche, un tipo que hemos diseñado nosotros al crear la clase Coche. Recuerda que Java diferencia entre mayúsculas y minúsculas, por eso coche y Coche son identificadores diferentes.

Fijémonos en los tipos de estas variables. Algunas de ellas, como coche, tienen por tipo el nombre de una clase. No es tan obvio eso mismo en la variable marca, pero observa que su tipo, String, comienza escrito por mayúsculas. Ya sabes que los nombres de clases, por convenio, empiezan por mayúsculas. Puedes pensar en Coche y String como tipos de datos compuestos, en oposición a los tipos simples restantes.

Los protagonistas de hoy son esos datos simples, atómicos, que luego utilizamos para construir otros tipos compuestos más elaborados. En Java son ocho y reciben el nombre de tipos primitivos.

Veamos cuáles son, agrupados por categorías.

Para declarar variables que contengan números enteros disponemos de cuatro tipos: byte, short, int y long. Se trata de enteros con signo (para valores positivos y negativos) y la diferencia entre ellos no es otra sino el número de bytes que ocupan en memoria y, por lo tanto, el rango numérico que pueden representar.

byte –> 1 byte (8 bits)
Rango: -128 / +127

short –> 2 bytes (16 bits)
Rango: -32768 / +32767

int –> 4 bytes (32 bits)
Rango: –2147483648 / +2147483647

long –> 8 bytes (64 bits)
Rango: –9223372036854775808 / +9223372036854775807

Como veremos cuando tratemos el tema de los literales, int es el tipo favorito de Java para lidiar con enteros. De ahí que a menudo nos planteemos una cuestión: ¿merece la pena la utilización de tipos como byte o short? Para aplicaciones sencillas, en las que la optimización del uso de memoria puede no ser relevante, no habría inconveniente. Pero imagina, por ejemplo, un programa que tuviera que manipular arrays grandes de enteros tipo byte (hablaremos de los arrays a su debido momento, pero por ahora basta con que sepas que son estructuras que permiten almacenar muchos elementos de un mismo tipo). Utilizar 4 bytes por cada elemento en lugar de 1, cuando son muchos, podría implicar un desperdicio de memoria crítico. Además, definir adecuadamente el tipo de los datos, dimensionándolos a lo estrictamente necesario, ayuda a mejorar la legibilidad y la comprensión del programa.

Para trabajar con números decimales disponemos de los tipos float y double. Están basados en el estándar IEEE 754 de representación en coma flotante. Si no has oído hablar de ese estándar hasta ahora y no sabes qué es eso de la mantisa y el exponente, te recomiendo que hagas una sencilla búsqueda en Google y te informes. Es una lectura que todo el mundo que trabaja con ordenadores debe hacer al menos una vez en su vida.

La diferencia entre float y double estriba, al igual que con las distintas opciones para números enteros, en el tamaño que ocupan: 32 bits el tipo float y 64 el tipo double, representando los números decimales con precisión simple o doble, respectivamente. Esto determinará tanto el máximo valor como el mínimo valor que podremos representar.

float –> 4 bytes (32 bits)
Mínimo: ±1.40239846E-45
Máximo: ±3.40282347E+8

double –> 8 bytes (64 bits)
Mínimo: ±4.94065645841246544E-324
Máximo: ±1.79769313486231570E+308

Aprecia la notación exponencial, no sería práctico escribir aquí un chorizo de trescientas cifras.

El tipo double es el favorito de Java al tratar números decimales. No obstante, como sucedía con los enteros, habrá situaciones en las que el ahorro de memoria puede ser un factor determinante que requiera una declaración de variables austera con float.

Para almacenar un carácter simple, Java dispone del tipo primitivo char, que ocupa 16 bits. Con él podemos representar caracteres Unicode (¡toda una bendición!) comprendidos entre ‘\u0000’ (0) y ‘\uFFFF’ (65535).

El octavo magnífico de nuestra serie es el tipo boolean, que admite dos posibles valores: true o false. Sólo se necesita un bit para almacenar dos estados posibles, pero el tamaño real que ocupa una variable boolean depende de la plataforma y de la implementación particular en Java. No es una cuestión importante pues, como hemos dicho, sólo se utiliza un bit, se guarde como se guarde.

Lo que resulta significativo es el hecho de que Java defina con exactitud el tamaño de sus tipos primitivos (sin contar boolean). No hay que perder de vista que Java está pensado como lenguaje multiplataforma. Si has programado en otros lenguajes y entornos quizás hayas constatado que el tamaño de un entero está muy relacionado con la arquitectura en particular. ¿Cómo es posible que Java logre esa independencia de la plataforma?

La clave es entender que cuando escribes un programa Java no lo estás haciendo directamente para tu sistema, sino para una una abstracción que es la máquina virtual Java (que, naturalmente, sí que es dependiente de la plataforma). Esa es la magia tras el slogan de Java, «escribe una vez, ejecuta en todas partes», que permite que el código escrito para una plataforma funcione directamente y sin correcciones (en términos generales, no siempre es así) en cualquier otra en la que exista una máquina virtual Java.

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2014/05/java-los-ocho-magnificos/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Índice completo de artículos sobre Java.

Python – Un poco de orden, por favor

Objetivo: mostrar cómo ordenar los elementos de una lista.

Benditas sean las listas. ¡Qué sería de nosotros, pythonistas, sin su admirable flexibilidad! He perdido la cuenta de los problemas que he podido resolver con elegancia apoyándome simplemente en estas sólidas estructuras.

Vamos a ampliar el repertorio de las posibilidades que nos ofrecen las listas. Nos ocuparemos hoy de ordenarlas.

Tomemos, por ejemplo, la siguiente lista numérica:

>>> a = [7, -1, 5, 3]

Ordenarla resulta tan sencillo como aplicar el método sort(), disponible en los objetos de tipo lista:

>>> a.sort()
>>> a
[-1, 3, 5, 7]

Bien simple. No obstante hay algo que debes tener siempre presente: esta modificación es «in situ», atacando directamente al objeto original, sin crear una copia.

Si lo que quieres es generar una nueva lista ordenada, pero sin afectar la original, puedes hacer uso de la función sorted(), que toma como argumento una secuencia y devuelve otra diferente ordenada.

>>> a = [7, -1, 5, 3]
>>> b = sorted(a)
>>> a
[7, -1, 5, 3]
>>> b
[-1, 3, 5, 7]

Mucho cuidado con hacer esto:

>>> a = [7, -1, 5, 3]
>>> b = a.sort()

Naturalmente, a se modificaría, ordenándose. ¿Pero qué crees que valdría b?

>>> print(b)
None

Nada. b no vale nada.

Si no entiendes por qué sucede esto, no te pierdas la lectura del artículo Python – Hace falta valor, en el que se desentraña el misterio.

Lo bueno de la función sorted() es que el argumento puede ser una secuencia en general, no solamente una lista. Así, objetos no mutables, como las tuplas, que no disponen del método sort(), podrían beneficiarse de su utilización.

La única limitación de sort() y sorted() es que los elementos han de ser comparables. Si no, Python difícilmente podrá deducir su orden.

La siguiente lista, con tipos diferentes, no podrá ser ordenada por sort():

>>> listamixta = [1, 'a', 5, 'casa']
>>> listamixta.sort()
Traceback (most recent call last):
  File "<pyshell#83>", line 1, in <module>
    listamixta.sort()
TypeError: unorderable types: str() < int()

Ordenar una lista en sentido inverso, de mayor a menor, es igualmente fácil haciendo uso de un argumento opcional, reverse:

>>> a = [7, -1, 5, 3]
>>> a.sort(reverse = True)
>>> a
[7, 5, 3, -1]

La función sorted() dispone también de la misma posibilidad:

>>> a = [7, -1, 5, 3]
>>> sorted(a, reverse = True)
[7, 5, 3, -1]

Observa que, en este último ejemplo, a no ha modificado su valor, puesto que sorted() ha creado un objeto diferente:

>>> a
[7, -1, 5, 3]

Voy a plantearte ahora un problema interesante que servirá de preludio al argumento que presentaremos a continuación y que aumentará sobremanera la potencia de nuestras ordenaciones.

Imagina que queremos ordenar alfabéticamente la siguiente lista:

>>> frutas = ['pera', 'Manzana', 'fresa']

Observa que he comenzado en mayúsculas la palabra Manzana.

El método sort(), estrictamente, cumple su función:

>>> frutas.sort()
>>> frutas
['Manzana', 'fresa', 'pera']

Las letras mayúsculas se almacenan internamente con un código más bajo que las correspondientes minúsculas, de modo que Manzana aparece antes que fresa, pese a que tal vez no fuera eso lo que nos gustaría.

¿Cómo hacer para que la ordenación no tenga en cuenta que la M está en mayúsculas y la trate como si fuera minúscula, pero dejando que aparezca en el resultado tal como fue escrita?

Imagina que podemos crear un tratamiento temporal previo que procese cada término conviertiéndolo completamente en minúsculas para que luego sort trabaje sobre ese resultado, pero sin olvidar cuáles eran los términos originales.

Esto se logra con un nuevo argumento, key:

>>> frutas = ['pera', 'Manzana', 'fresa']
>>> frutas.sort(key = str.lower)
>>> frutas
['fresa', 'Manzana', 'pera']

Y ahora sí, fresa aparece antes que Manzana.

Presta atención: key recibe como valor el nombre de una función que requiera un único argumento. El valor devuelto por la función será utilizado después como base de trabajo para la ordenación.

El método lower(), que se aplica a los objetos de tipo str, strings, convierte una cadena de caracteres toda en minúsculas. Observa que he dicho el nombre de una función, por eso lower se muestra sin paréntesis en el argumento key.

Otro ejemplo. Reorganicemos nuestra macedonia, pero esta vez de modo que las frutas aparezcan ordenadas de acuerdo a su longitud:

>>> frutas = ['pera', 'Manzana', 'fresa']
>>> frutas.sort(key = len)
>>> frutas
['pera', 'fresa', 'Manzana']

Como sabes, la función len devuelve el número de elementos de una secuencia, esto es, el número de letras de que se compone un string, en nuestro caso. Ese total será tomado como criterio para la ordenación.

Podemos utilizar key para saltarnos la limitación que nos impedía ordenar listas mixtas.

>>> listamixta = [1, 'a', 5, 'casa']
>>> listamixta.sort(key = str)
>>> listamixta
[1, 5, 'a', 'casa']

La función str convierte un objeto en string, de modo que los números ya serán comparables con el resto de valores y sort() podrá realizar su trabajo. Observa que la lista resultado sigue siendo mixta; la conversión a string sólo se ha realizado a nivel interno.

Podemos ir más allá y crear incluso nuestras propias funciones para utilizarlas en sort().

Por ejemplo, esta sencilla función invierte un string:

>>> def invertir(cadena):
  return cadena[::-1]

>>> invertir('pimiento')
'otneimip'

Si no entiendes cómo trabaja esta función, echa un vistazo al artículo El mundo al revés.

Vamos a aprovecharla entonces como criterio de ordenación para que sort() ordene la lista atendiendo a la última letra de cada palabra, en lugar de la primera, tal como haría por omisión.

>>> planetas = ['mercurio', 'venus', 'tierra', 'marte']
>>> planetas.sort(key = invertir)
>>> planetas
['tierra', 'marte', 'mercurio', 'venus']

Fíjate por dónde, nuestro planeta el primero…

La función sorted(), como cabría esperar, dispone también del argumento key.

Interesante. Las posibilidades creativas son inmensas. Prácticamente significa que puedes hacer que Python ordene una lista o, por lo general, cualquier secuencia, por cualquier criterio que puedas imaginar. Es lo que me encanta de Python: este lenguaje rezuma creatividad lo mires por donde lo mires.

Javier Montero Gabarró


Python – Un poco de orden, por favor


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Consulta el índice completo de artículos relacionados con Python.

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.plugin cookies

ACEPTAR
Aviso de cookies