MuseScore: Introducción de acordes cifrados – 1

Objetivo: conocer los fundamentos para la introducción de acordes cifrados en MuseScore.

La partitura de una pieza no es otra cosa sino una abstracción visual de un fenómeno musical de naturaleza sonora. Quien la escribe pretende reflejar, con mayor o menor precisión, algo que sus oídos han captado previamente.

El nivel de abstracción podrá ser alto o bajo en función de las capacidades del transcriptor y de su necesidad. Si lo que desea es lograr un reflejo lo más fiel posible de la pieza, deberá esmerarse en matizar con precisión lo que está sucediendo con cada instrumento. Pero si tan sólo quiere ofrecer un arreglo reducido, puede optar por simplificar lo que acontece en el plano vertical y optar por acordes cifrados en su lugar.

Seguro que conoces los famosos Real Books de jazz, en los que apenas te encuentras una simple partitura con la melodía y unos acordes cifrados en su parte superior. Yo di mis primeros pasos con la guitarra estudiando la obra de los Beatles, con sus discos y un libro con las transcripciones simples de la melodía y los acordes cifrados (con una leyenda en lo más alto de cómo formarlos en el instrumento).

Ese es el mayor nivel de abstracción: reducir la pieza a una melodía con la armonía simplificada en forma de acorde cifrado. No hay más información: será decisión de los ejecutantes optar por un tipo de arreglo u otro.

Con MuseScore, naturalmente, también puedes escribir cifrados en la parte superior de los pentagramas. De eso es lo que nos ocuparemos hoy.

Vamos a realizar un ejercicio sencillo sobre una partitura que ya hemos utilizado en artículos anteriores: el Cumpleaños feliz. Si quieres practicar esto a la vez que lo vas leyendo, puedes descargarte aquí el fichero .mscz que he preparado al efecto.

Haz clic sobre la imagen si quieres verla en tamaño natural.

Aunque en la clave de Fa ya nos encontramos una armonización básica, vamos a colocar los acordes cifrados sobre la línea melódica presente en la clave de Sol. Esta información podría ser de mucha utilidad, por ejemplo, para un guitarrista que no supiera solfeo y quisiera acompañar la canción.

Comencemos plantando un acorde de Fa mayor sobre el Re del primer compás tras la anacrusa. Haz clic sobre él para seleccionarlo y dejarlo en azul.

Eso es lo primero que debes retener: cada cifra de acorde va asociada a una nota o silencio y MuseScore la representará como texto justo sobre ella. En breve veremos que podemos reajustar la posición finalmente, pero por mucho que la muevas seguirá asignada a la misma nota.

Pulsa a continuación el menú Crear | Texto | Nombre del acorde. Te aparecerá un pequeño rectángulo de edición azul dentro del cual escribirás el nombre del acorde.

Escribe la letra F mayúscula, cifrado del acorde Fa mayor y pulsa Esc para abandonar la edición.

Repite esta operación para el resto de los acordes y habrás terminado. No haría falta saber nada más.

Pero no lo hagas; vamos a aprender antes algunas técnicas interesantes.

Haz clic sobre el acorde y, sin soltarlo, arrástralo hasta otra posición. Verás que aparece una línea azul que enlaza el acorde con la nota o silencio al que está asociado.

Libera el ratón sobre la ubicación deseada y el acorde permanecerá enclavado en la nueva posición, aunque seguirá asociado, como has visto, a la misma nota.

Pulsa Control-Z para deshacer la operación y dejar el acorde en su posición original.

Coloquemos ahora un Do mayor sobre la nota Mi del siguiente compás. Selecciónala con el ratón y, a continuación pulsa Control-K, que es el atajo de teclado para lo que antes hicimos a través de los menús.

Escribe C, cifrado del acorde Do mayor, pero esta vez no pulses Esc para enclavar el acorde, sino Enter, a ver qué pasa. Observa que se te abre una nueva línea por si deseas agregar más información abajo.

Borra ese salto de línea, pero no pulses Esc sino la barra espaciadora: el cuadro de edición del nombre de acorde se traslada automáticamente sobre la siguiente nota o silencio.

Pulsa varias veces la barra espaciadora y comprueba el efecto. Para moverte hacia atrás pulsa Shift – Barra espaciadora.

Si quieres dar saltos más amplios, prueba a utilizar la tecla TAB: desplazará el cuadro de edición a la primera nota del compás siguiente. De igual modo, Shift-TAB retrocede compases hacia atrás.

Cuando llegues al Si bemol mayor, escribe el símbolo bemol como una b minúscula:

Ahora, cuando pulses TAB o Espacio para desplazar el cuadro de edición, verás que MuseScore se ocupa de cambiar automáticamente la b minúscula por el símbolo de bemol real:

Lo mismo sucedería con el sostenido: escribe la almohadilla en el teclado y MuseScore se ocupará de cambiarla por el símbolo correcto.

Completa lo que resta de la partitura:

La magia de todo esto es que, a pesar de que los nombres de acordes no aparentan ser más que cuadros de texto, están dotados de cierta inteligencia. Vamos a transponer la pieza a otra tonalidad aplicando el método que describí en otro artículo.

En la imagen, hemos indicado que transpondremos a Do mayor. Pero fíjate en la última marca de verificación: Transportar los Nombres de Acordes. Si la dejamos marcada, todo el cifrado de acordes se transpondrá también a la nueva tonalidad, no sólo las notas.

Comprobemos el resultado:

Y ahí está: Cumpleaños feliz en Do mayor.

Ojalá me cante mañana alguien esta canción…

Javier Montero Gabarró


MuseScore: Introducción de acordes cifrados – 1


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


Este es el índice completo de artículos sobre MuseScore.

LaTeX: Controlando la indentación de los párrafos

Objetivo: mostrar cómo controlar la indentación (sangría) que LaTeX realiza automáticamente sobre la primera línea de cada párrafo.

Ya sabes que \LaTeX, por defecto, indenta la primera línea de cada párrafo. De este modo, salta a la vista donde empieza uno y termina otro, incluso sin existir separación entre ellos (algo que, como vimos, también sucede por defecto).

Naturalmente, este comportamiento puede ser modificado fácilmente y podemos especificar con precisión cuánto queremos que quede indentada la primera línea de cada párrafo.

Es una cuestión tan simple como modificar una de las magnitudes de longitud de \LaTeX. Es semejante a lo que hicimos con \parskip para controlar el espaciado entre párrafos.

Deja que te presente la magitud \parindent.

Imagina que quieres definir una indentación de 12pt en la primera línea de todos los párrafos del documento. Escribe el siguiente comando en el preámbulo:

\setlength{\parindent}{12pt}

Es exactamente lo mismo que hacíamos con \parskip: el comando \setlength, seguido de la magnitud que queremos modificar, entre llaves, y de su valor, entre llaves también, sin olvidar especificar las unidades. El comando tiene dos pares de llaves porque son dos parámetros obligatorios. Recuerda que los parámetros opcionales figuraban entre corchetes.

El preámbulo es, desde luego, el mejor sitio para este tipo de comandos que afectan al diseño global, pero también puedes hacer uso de ellos dentro del cuerpo del documento. En este caso, los cambios en la sangría sólo aparecerán en los párrafos posteriores a su aparición y se mantendrán vigentes hasta que otro comando similar vuelva a alterar su valor.

Si deseas limitar su efecto a uno o más párrafos, puedes incluir el comando dentro de un grupo delimitado por llaves. Es decir:

{\setlength{\parindent}{12pt}.... párrafos afectados....}

Sólo aquellos párrafos contenidos entre las llaves se verán afectados; los restantes mantendrán la indentación especificada en el preámbulo (o la que hay por defecto, de no indicar una).

Las buenas prácticas recomiendan emplear unidades de longitud relativas en vez de absolutas. Recuerda, por ejemplo, la em, que equivale a la anchura de la letra m. Esta anchura es, obviamente, mayor, si el tamaño de la fuente es mayor. Hacer esto garantiza que la indentación sea proporcional al tamaño de la fuente. Si en algún momento quieres modificar el tamaño base en tu documento, las sangrías se ajustarán proporcionalmente, algo que te evitará tener que retocarlas después.

El siguiente comando establece la indentación a una vez y media la anchura de una letra eme:

\setlength{\parindent}{1.5em}

La indentación de los párrafos es algo común en el mundo anglosajón, pero no tanto en el nuestro, pues preferimos no hacerlo.

El siguiente comando, en el preámbulo del documento, anula el sangrado de los párrafos:

\setlength{\parindent}{0cm}

Fíjate en que, a pesar de que el valor es cero, se necesita indicar las unidades. Habría sido lo mismo, desde luego, escribir 0pt, 0mm o 0em.

Puede que desees que sólo un párrafo concreto quede sin indentación. Podrías utilizar el comando anterior encerrado en un grupo con llaves, aunque mucho más sencillo es hacer uso de otro comando simple:

\noindent

Coloca este comando al principio del párrafo que no desees sangrar y desactivarás momentáneamente, sólo durante ese párrafo, la indentación existente.

Si no te gusta indentar los párrafos, asegúrate de que te guste agregar una separación entre ellos tocando la magnitud \parskip. De no hacerlo, si la última línea de un párrafo es larga, no podrás distinguir si estás o no en el mismo párrafo o en el siguiente.

O, mejor aún, utiliza el paquete parskip (el mismo nombre que la magnitud), que ya tratamos, y que se ocupa de establecer a cero el sangrado y de definir una línea de separación entre párrafos. Además, mejora el tratamiento que se le da a las listas, que pueden verse más afectadas por haber tocado la magnitud \parskip.

Una última observación para los más estudiosos. Si has estado leyendo sobre \LaTeX puede que te hayas encontrado este otro estilo de modificación de magnitudes:

\parindent=8mm

Esa era la forma de hacer estas cosas a la antigua usanza. Evita su utilización aunque tu sistema la permita y te ahorrarás problemas de compatibilidad. Emplea, en su lugar:

\setlength{\parindent}{8mm}

Javier Montero Gabarró


LaTeX: Controlando la indentación de los párrafos


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 relacionados con \LaTeX.

MySQL: Insertando datos sin facilitar todos los campos

Objetivo: mostrar cómo insertar filas en una tabla MySQL sin facilitar todos los campos, es decir, decidiendo selectivamente cuáles rellenaremos.

En el artículo anterior aprendimos a insertar un registro en una tabla MySQL con el comando:

INSERT INTO nombre_tabla VALUES (lista de valores separados por comas)

Vimos que la lista de valores debía coincidir, en número y orden, con los campos de la tabla.

Pero, ¿y si no quisiéramos rellenar la fila completamente? Quizás no tengamos los datos completos y nos gustaría tener la posibilidad de agregarlos posteriormente.

MySQL permite que agreguemos filas indicando selectivamente qué columnas queremos rellenar.

Recuperemos alguna de las tablas de la sesión anterior, como la de fichajes:

mysql> DESC fichajes;
+---------+------+------+-----+---------+-------+
| Field   | Type | Null | Key | Default | Extra |
+---------+------+------+-----+---------+-------+
| fecha   | date | YES  |     | NULL    |       |
| entrada | time | YES  |     | NULL    |       |
| salida  | time | YES  |     | NULL    |       |
+---------+------+------+-----+---------+-------+
3 rows in set (0.00 sec)

en la que ya teníamos algunos datos:

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
+------------+----------+----------+
3 rows in set (0.00 sec)

Imaginemos que queremos introducir datos para el día 4 de julio, pero sólo conocemos la hora de entrada. Observa la nueva versión de INSERT:

mysql> INSERT INTO fichajes (fecha, entrada) VALUES ('2012-07-04', '07:25');
Query OK, 1 row affected (0.09 sec)

A continuación del nombre de la tabla indicamos, entre paréntesis, el nombre de los campos en los que vamos a introducir datos. En la lista VALUES facilitamos los datos correspondientes a esos campos, en el mismo orden en el que están referenciados.

Veamos nuestra nueva fila:

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
| 2012-07-04 | 07:25:00 | NULL     |
+------------+----------+----------+
4 rows in set (0.00 sec)

Observa que el dato que no hemos indicado se rellena con NULL, que es el valor por defecto que tiene el campo salida (observa más arriba la estructura de la tabla tras DESC). Más adelante veremos cómo indicar valores por defecto a la hora de crear una tabla.

El orden de los datos en VALUES no tiene por qué ser el que les corresponde naturalmente. La única condición es que coincida con el especificado en la lista de campos.

Por ejemplo, vamos a agregar un nuevo registro, pero esta vez indicaremos la entrada antes que la fecha:

mysql> INSERT INTO fichajes (entrada, fecha) VALUES ('07:45', '2012-07-05');
Query OK, 1 row affected (0.05 sec)

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
| 2012-07-04 | 07:25:00 | NULL     |
| 2012-07-05 | 07:45:00 | NULL     |
+------------+----------+----------+
5 rows in set (0.00 sec)

Naturalmente, también podemos agregar varias filas en una única operación, tal como explicamos en el artículo anterior:

mysql> INSERT INTO fichajes (entrada, fecha) VALUES
    -> ('07:30', '2012-07-06'),
    -> ('07:15', '2012-07-07'),
    -> ('08:01', '2012-07-08');
Query OK, 3 rows affected (0.11 sec)
Records: 3  Duplicates: 0  Warnings: 0

La única condición, como vemos, es separar los registros, rodeados entre paréntesis, mediante comas.

Comprueba que las tres filas insertadas aparecen correctamente:

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
| 2012-07-04 | 07:25:00 | NULL     |
| 2012-07-05 | 07:45:00 | NULL     |
| 2012-07-06 | 07:30:00 | NULL     |
| 2012-07-07 | 07:15:00 | NULL     |
| 2012-07-08 | 08:01:00 | NULL     |
+------------+----------+----------+
8 rows in set (0.00 sec)

Esta ha sido la pieza de hoy. Tú decides qué hacer con ella…

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/07/mysql-insertando-datos-sin-facilitar-todos-los-campos/


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


¡Accede al índice con todos los artículos sobre MySQL!

Python: Conjuntos inmutables con frozenset

Objetivo: presentar el tipo frozenset para la implementación de conjuntos inmutables.

Al igual que las listas encuentran en las tuplas su versión inmutable, los conjuntos, que como vimos quedaban representados por el tipo set, hallan su inalterabilidad a través del tipo frozenset.

Podríamos traducir frozenset por algo así como conjunto congelado, término que muestra claramente su carácter estático. Podemos pensar en un frozenset como en un set en el que no podemos modificar su composición una vez creado.

Veamos cómo creamos un frozenset:

>>> c1 = frozenset({'pradera', 2, 'pimiento'})
>>> c1
frozenset({'pimiento', 2, 'pradera'})

Presta mucha atención: empleamos el constructor frozenset, facilitando, como argumento, entre paréntesis, un conjunto definido explicitamente.

En general, el argumento no tiene por qué ser un conjunto, sino que sirve cualquier tipo de objeto iterable, como una lista. Más adelante hablaremos formalmente de qué significa exactamente eso de ser iterable, pero por el momento quédate con que un iterable es cualquier objeto que puede ser recorrido de principio a fin dentro de un bucle for.

Por lo tanto, la definición anterior también podrías haberla hecho así:

>>> c1 = frozenset(['pradera', 2, 'pimiento'])
>>> c1
frozenset({'pimiento', 2, 'pradera'})

El resultado, como ves, es el mismo empleando corchetes (listas) que llaves (conjuntos). O incluso si facilitas unta tupla como argumento:

>>> c1 = frozenset(('pradera', 2, 'pimiento'))
>>> c1
frozenset({'pimiento', 2, 'pradera'})

Date cuenta de que, aunque estemos facilitando varios datos a través de un conjunto, lista o tupla, en realidad dentro de frozenset hay un único argumento. El siguiente código sería erróneo:

>>> frozenset('pimiento', 2, 'pradera')
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    frozenset('pimiento', 2, 'pradera')
TypeError: frozenset expected at most 1 arguments, got 3

ya que hemos introducido tres argumentos y, como informa el código de error, cómo máximo admite uno.

En efecto: como máximo un argumento. O, lo que es lo mismo, uno o ninguno.

>>> c2 = frozenset()
>>> c2
frozenset()

Como vemos, cuando no facilitamos ningún argumento, creamos un frozenset vacío.

Las cadenas de caracteres también son iterables, pues pueden ser recorridas de principio a fin con un bucle for. Por lo tanto, también nos pueden servir para generar un frozenset:

>>> c3 = frozenset('pradera')
>>> c3
frozenset({'a', 'p', 'r', 'e', 'd'})

Observa qué ha pasado: se ha descompuesto la cadena en sus caracteres individuales, eliminando las repeticiones. Esto es algo natural, ya que los conjuntos no pueden tener elementos repetidos, como vimos en los últimos artículos.

Esta manera de crear un frozenset a través de su constructor también es válida para el tipo set.

>>> c4 = set('la casa de la pradera')
>>> c4
{'a', ' ', 'c', 'e', 'd', 'l', 'p', 's', 'r'}

Una forma muy rápida de crear un conjunto a partir de un string, como podemos ver.

Set y frozenset son hermanos, por lo que puedes emplear muchos de los operadores y métodos que ya aprediste con set. Realizemos, por ejemplo, una unión:

>>> c1 = frozenset({1, 2, 3})
>>> c2 = frozenset({4, 5, 6})
>>> c1 | c2
frozenset({1, 2, 3, 4, 5, 6})

En cambio, ya que los frozenset son inmutables y no podemos modificarlos, no aceptan aquellos métodos que traten de alterar su composición. Intentemos agregar un nuevo elemento a c1 y veamos qué sucede:

>>> c1.add(5)
Traceback (most recent call last):
  File "<pyshell#20>", line 1, in <module>
    c1.add(5)
AttributeError: 'frozenset' object has no attribute 'add'

El mensaje es rotundo: el objeto frozenset no tiene método add.

¿Por qué usar un frozenset en lugar de un set? Una razón importante puede ser para garantizar que nuestro código no alterará una estructura de datos que no debamos modificar. Además, como veremos en breve cuando comencemos con los diccionarios, las claves de estos han de ser de un tipo inmutable, como son los strings, tuplas o frozensets, pero no servirían ni las listas ni los sets, que son modificables.

El tema de la mutabilidad en Python puede resultar un tanto misterioso si estás habituado a otros lenguajes de programación. Merecerá que se le dedique un artículo monográfico…

Javier Montero Gabarró


Python: Conjuntos inmutables con frozenset


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.

BitBite English #30: as a matter of course

Let me give you a quick piece of knowledge…

Aprender un idioma se asemeja a ser coleccionista. Coleccionas pequeñas piezas que interiorizas a través de la práctica.

La pieza de hoy es a matter of course. Si ya es tuya, quizás no venga mal recordarte que la posees; si no es el caso, considera esta breve lectura una invitación a que lo sea.

Pero es sólo una invitación: no la poseeras salvo si pones de tu parte para que así sea.

Poner de tu parte no significa otra cosa que usarla. Tan pronto termines de leer esto, intenta crear un par de frases con ella.

Repítelo al día siguiente y al otro. Si es preciso, mantén un registro de cada pieza que incorpores a tu repertorio.

Try to practice every single word or phrase you learn as a matter of course.

as a matter of course; por costumbre, por principio, automáticamente, de modo habitual

Cuando haces algo as a matter of course lo haces automáticamente, sin pararte a cuestionarlo.

Do you think chess should be taught in school as a matter of course?

I really think so, as a matter of fact… I love chess.

Your move: make this piece yours!

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/07/bitbite-english-30-as-a-matter-of-course/


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 BitBite English si te gusta esta serie.

Construcción de acordes 17: Menor séptima con novena

Objetivo: conocer la fórmula de un acorde menor séptima con novena y aprender a identificar las notas que lo constituyen en cualquier tonalidad.

Si te has leído pacientemente todas las entregas hasta aquí, estarás sin duda en condiciones de seguir ya tu camino solo. Mi verdadero trabajo no consiste en realizar una enumeración fría y sistemática de todos los tipos de acordes, sino en hacer que seas capaz de comprender qué hay detrás de su nombre y que sepas identificar las notas que hacen posible su magia colectiva.

De este modo, pretendo que puedas mirar cara a cara a cualquier tipo de acorde con que te cruces, aunque no haya sido tratado aquí y estés capacitado para desentrañar su misterio sin ninguna dificultad.

Pero, no obstante, aunque ya empiece a parecerte más de lo mismo (señal de que habré logrado mi objetivo), permíteme que, por motivos de compleción (acción y efecto de completar), te presente el acorde de hoy: menor séptima con novena.

Una breve pasada por su nombre nos dice que no es más que la cuatriada menor séptima, que ya conocemos, extendida hasta la novena.

Recordemos el acorde menor séptima:

m7 --> 1 - b3 - 5 - b7

Y agreguémosle la novena:

m7(9) --> 1 - b3 - 5 - b7 - 9

Y ya está, no hay más misterio.

Este tipo de acorde podrás encontrártelo cifrado también como m9. Que no te confunda, es el mismo que el anterior, la séptima viene implícita.

Y ahora el par de ejemplos de rigor: Cm7(9) y Am7(9).

Refresquemos la metodología: partimos de la escala mayor (aunque el acorde sea menor) construida sobre la fundamental de cada acorde.

Do mayor: C - D - E - F - G - A - B - C - D (extendiendo hasta la novena, ya que la necesito)

La mayor: A - B - C# - D - E - F# - G# - A - B

Y tomamos los grados indicados en la fórmula.

Cm7(9) --> C - Eb - G - Bb - D

Am7(9) --> A - C - E - G - B

Y así, sin pena ni gloria, otro acorde más para seguir completando la tabla de referencia.

Javier Montero Gabarró


Construcción de acordes 17: Menor séptima con novena


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 de todos los artículos de armonía.

LaTeX: Notación relacionada con los conjuntos

Objetivo: aprender a generar en LaTeX la simbología relacionada con los conjuntos matemáticos.

Hace tan sólo dos días escribía un artículo sobre programación en Python relacionado con los conjuntos y caí en la cuenta de que aún no había mencionado nada sobre ellos en \LaTeX. No es la primera vez que aprovecho una misma temática para enfocarla bajo la luz de distintas disciplinas (como las listas en Python, en LaTeX o en HTML). De modo que quiero compartir hoy contigo lo que sé sobre notación de conjuntos en LaTeX, es decir, mostrarte cómo pintar esos simbolitos de unión, intersección, pertenencia, etc.

Comencemos describiendo los elementos que definen un conjunto:

La única pega que tiene esto es la generación de las llaves, pues sabes que son un símbolo reservado de \LaTeX.

Para poder escribir las llaves, debes escaparlas con \{ y \}, de modo que el código que genera la imagen de la figura es el siguiente:

\[
A=\{1, 2, 3, 4\}
\]

Pero esto puede suponer un problema, al igual que sucedía con los paréntesis: si el contenido presenta varias alturas, las llaves se quedarán pequeñas. Obsérvalo en la siguiente imagen:

De modo que toma nota del comando inteligente para generar llaves: \left\{ para la llave de apertura y \right\} para la de cierre. Ahora está mucho mejor:

\[
A=\left\{\frac{1}{2}, 2, 3, 4\right\}
\]

Comprendido esto, continuemos con la pertenencia:

Los comandos para indicar pertenencia o no pertenencia son \in y \notin, respectivamente:

\[
4 \in A
\]

\[
5 \notin A
\]

Voy a explicarte otra forma más de generar el símbolo de no pertenencia y que aplicaremos después para la forma negada del operador de inclusión. Basta con que precedas el operador a negar con el comando \not. Obsérvalo:

\[
5 \not \in A
\]

El resultado es exactamente el mismo.

Para la unión e intersección disponemos de los comandos \cup y \cap, respectivamente. La elección de estos términos no es arbitraria: cup significa taza en inglés, que es como la U de la unión. En cambio, cap significa gorro, un objeto que podemos asimilar fácilmente a la U invertida de la intersección.

\[
A \cup B
\]

\[
A \cap B
\]

Si te gusta indicar el complementario de un conjunto con una barra horizontal, toma nota del comando \overline, que dibujará una línea horizontal sobre aquello que facilites como argumento entre llaves. Por ejemplo, para generar la siguiente ley de Morgan

habría que escribir el siguiente código:

\[
\overline{A \cup B}=\overline{A} \cap \overline{B}
\]

El símbolo de inclusión, contenido en, lo creamos a través del comando \subset (subconjunto). Su variante, contiene a, se logra con \supset (superconjunto).

\[
A \subset B
\]

\[
B \supset A
\]

Si agregas eq, de equal, al final de estos comandos, obtienes la versión con igualdad:

\[
A \subseteq B
\]

\[
B \supseteq A
\]

Para el no incluido y el no contiene, precedemos el comando con \not, de igual modo que hicimos con la no pertenencia. Observa estos dos ejemplos:

\[
A \not \subset B
\]

\[
B \not \supseteq A
\]

Lo he soltado, ya me he quedado más a gusto…

Javier Montero Gabarró


LaTeX: Notación relacionada con los conjuntos


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 relacionados con \LaTeX.

Correr mientras la ciudad duerme

Correr limpia y renueva…

Qué tendrá este deporte que, por cerca o lejos que vayamos, por lento o rápido que corramos o por mucho o poco que variemos nuestros recorridos, nunca albergamos la sensación de estar haciendo algo rutinario.

Después de cualquier entrenamiento, por suave o exigente que nos haya resultado, siempre hay una percepción de prueba superada, de triunfo sobre nosotros mismos, de victoria sobre nuestros miedos más íntimos. Al menos, es lo que a mí me sucede, pero apostaría que también es así en la gran mayoría de los que practican este deporte.

Y cuando uno se levanta de la cama antes de las seis de la mañana, se bebe dos vasos de agua y, en ayunas, se echa a la calle a correr mientras la ciudad aún duerme, esa sensación de victoria es el doble de intensa.

Correr de noche, con las calles desiertas y que te sorprenda, casi sin darte cuenta, el amanecer, es algo que reconforta física y espiritualmente. Es como volver a nacer, o como si desde la montaña más alta contemplaras el mundo a tus pies.

Ese horario se ha convertido ya en mi favorito para entrenar, casi una necesidad para mí si quiero seguir corriendo en Sevilla durante el verano.

Y después, naturalmente, tras el oportuno estiramiento, una buena ducha y un desayuno que parece nutrir instantáneamente cada célula del cuerpo.

Cuando, poco después, me dirijo al trabajo, tengo la sensación de que el tiempo ha transcurrido de una manera especial y me parece muy lejano el momento en que me eché a correr.

Y me dispongo sereno a afrontar las vicisitudes que el día me habrá de deparar, pero con ese convencimiento de que lo más importante y valioso que tenía que hacer ya está hecho.

(7’35 Km, 44 min, 5:59 min/Km)

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/07/correr-mientras-la-ciudad-duerme/


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

Python: Subconjuntos – Conjuntos disjuntos

Objetivo: implementar los conceptos de subconjuntos y conjuntos disjuntos en Python.

Vamos a ir concluyendo el tema de los conjuntos, que tengo interés en presentar pronto otra de las superestructuras fabulosas de Python, los diccionarios.

La teoría nos dice que A es subconjunto de B cuando A está incluido en B, que es lo mismo que decir que B contiene a A.

Para implementar estos conceptos en Python, disponemos de los operadores de comparación habituales:

== igual
!= distinto
>  mayor
>= mayor o igual
<  menor
<= menor o igual

A es un subconjunto de B cuando todos los elementos de A están incluidos en B, relación que expresamos por

A <= B

que es equivalente a

B >= A

Puede interesarte también la inclusión estricta:

A < B, que es lo mismo que decir B > A

Practiquemos estos operadores con los siguientes conjuntos:

>>> c1 = {1, 2, 3}
>>> c2 = {1, 2, 3}
>>> c3 = {1, 2, 3, 4, 5, 6}
>>> c4 = {2, 4, 6}
>>> c5 = {1, 3, 5}

Observa que c1 y c2 son iguales, pues contienen los mismos elementos

>>> c1 == c2
True

pero c2 y c3 no lo son:

>>> c2 != c3
True

Sin embargo, c2 es un subconjunto de c3, pues todos los elementos de aquel están incluidos en este:

>>> c2 <= c3
True

A su vez, c1 es un subconjunto de c2, aunque sean iguales:

>>> c1 <= c2
True

Pero no lo sería en sentido estricto:

>>> c1 < c2
False

El concepto de subconjunto también está disponible como método:

>>> c1.issubset(c3)
True

que debe leerse como c1 es subconjunto de c3,

y es lo mismo que

c1 <= c3

También puedes expresarlo del siguiente modo:

>>> c3.issuperset(c1)
True

que debes leerlo como c3 es superconjunto de c1, que es lo mismo que decir que c3 contiene a c1:

c3 >= c1

Para finalizar, unas palabras sobre el concepto de conjuntos disjuntos. Sabemos que dos conjuntos son disjuntos cuando no tienen elementos en común, es decir, su intersección es el conjunto vacío.

En el artículo anterior tratamos la intersección, así que ya tenemos recursos para practicar esto sobre los conjuntos c4 y c5, que como puedes observar, son disjuntos:

>>> c4 & c5 == set()
True

Recuerda que set() simboliza el conjunto vacío, y no {}, que sería un diccionario vacío, como veremos muy pronto.

Pero esta instrucción podría prestarse a error fácilmente: el uso de set() o el orden de evaluación de los operadores.

¿Qué tal esta otra, más sencilla?

>>> c4.isdisjoint(c5)
True

Se acerca el final del repaso que le estamos dando a los conjuntos en Python. En la próxima entrega presentaremos el tipo frozenset, conjunto congelado, que es como el tipo set, pero inmutable.

Qué trascendente ha sonado esta última palabra; me está entrando hasta frío…

Javier Montero Gabarró


Python: Subconjuntos – Conjuntos disjuntos


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.

Insertando datos en nuestras tablas MySQL

Objetivo: aprender a agregar datos a una tabla en MySQL.

Hemos dedicado varios artículos a describir los distintos tipos de datos que existen en MySQL. Desde luego que aún nos quedan bastantes, pero he juzgado interesante hacer un pequeño alto en el camino para cambiar de tercio y darle más vidilla al aprendizaje.

A lo largo de esta serie, practicando los diversos tipos de datos, hemos creado muchas tablas de ejemplo. Pero las tablas vacías son como colegios sin niños, carentes de sentido.

Ha llegado el momento de que demos vida a nuestras tablas y aprendamos a insertar datos en ellas. Para ello, nada mejor que utilizar los ejemplos que ya creamos.

Recuperemos la tabla de consumibles, con la siguiente estructura:

mysql> DESC consumibles;
+------------+-------------+------+-----+---------+-------+
| Field      | Type        | Null | Key | Default | Extra |
+------------+-------------+------+-----+---------+-------+
| referencia | varchar(15) | YES  |     | NULL    |       |
| impresora  | varchar(20) | YES  |     | NULL    |       |
| stock      | int(11)     | YES  |     | NULL    |       |
+------------+-------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

Como puedes observar, la tabla consta de tres campos, dos de tipo VARCHAR para albergar cadenas de texto y otro de tipo INT para almacenar un número entero.

Vamos a agregar el primer registro. Presta atención al siguiente comando:

mysql> INSERT INTO consumibles VALUES ( 'ACME2598X', 'ACME INKJET Ultra', 5 );
Query OK, 1 row affected (0.12 sec)

El comando es INSERT INTO, seguido del nombre de la tabla y de la palabra VALUES que, entre paréntesis, contiene una lista con todos los campos de que consta el registro. Como siempre, no olvides el punto y coma final.

Atiende cuidadosamente: todos los campos de que consta el registro y, además, en el mismo orden en que aparecen en la estructura de la tabla.

Ya veremos qué hay más formas de introducir datos, pero primero debes manejarte bien con esta.

¡Qué emoción, verdad? Ya hay datos. Apuesto a que estás deseando verlos.

Aunque hablaremos de SELECT a su debido momento, quédate por ahora con el siguiente comando, que viene a significar algo así como «muéstrame todo el contenido de la tabla consumibles»:

mysql> SELECT * FROM consumibles;
+------------+-------------------+-------+
| referencia | impresora         | stock |
+------------+-------------------+-------+
| ACME2598X  | ACME INKJET Ultra |     5 |
+------------+-------------------+-------+
1 row in set (0.00 sec)

¡Ahí la tenemos, nuestra flamante primera fila de la tabla!

Durante muchos años, todo lo que he sabido de SQL se reducía a este simple comando SELECT.

Seguro que no puedes esperar al momento de introducir el segundo registro. Ejecutamos un nuevo comando INSERT INTO:

mysql> INSERT INTO consumibles VALUES ( 'ACME4501Y', 'ACME PseudoJET Plus', 12 );
Query OK, 1 row affected (0.05 sec)

Venga, veamos cómo ha crecido la tabla:

mysql> SELECT * FROM consumibles;
+------------+---------------------+-------+
| referencia | impresora           | stock |
+------------+---------------------+-------+
| ACME2598X  | ACME INKJET Ultra   |     5 |
| ACME4501Y  | ACME PseudoJET Plus |    12 |
+------------+---------------------+-------+
2 rows in set (0.00 sec)

¡Impresionante! Sigue añadiendo filas hasta que te canses….

Vamos a rellenar otra de las tablas con la que hemos estado trabajando recientemente:

mysql> DESC fichajes;
+---------+------+------+-----+---------+-------+
| Field   | Type | Null | Key | Default | Extra |
+---------+------+------+-----+---------+-------+
| fecha   | date | YES  |     | NULL    |       |
| entrada | time | YES  |     | NULL    |       |
| salida  | time | YES  |     | NULL    |       |
+---------+------+------+-----+---------+-------+
3 rows in set (0.05 sec)

El propósito de esta tabla es registrar los momentos de fichaje en una empresa. Agreguemos el primer registro:

mysql> INSERT INTO fichajes VALUES ('2012-07-01', '07:32', '17:14');
Query OK, 1 row affected (0.08 sec)

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
+------------+----------+----------+
1 row in set (0.00 sec)

También es posible agregar varias filas en una única operación. Observa cómo lo hago:

mysql> INSERT INTO fichajes VALUES
    -> ('2012-07-02', '08:15', '17:57'),
    -> ('2012-07-03', '07:31', '16:30');
Query OK, 2 rows affected (0.04 sec)
Records: 2  Duplicates: 0  Warnings: 0

He pulsado ENTER después de VALUES para hacer el comando más legible. Observa que cada registro está contenido entre paréntesis, separando uno de otro mediante una coma.

Ejecutemos el comando estrella de SQL y veamos nuestra tabla con sus nuevos datos:

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
+------------+----------+----------+
3 rows in set (0.00 sec)

mysql> exit
Bye

Javier Montero Gabarró


Insertando datos en nuestras tablas MySQL


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


¡Accede al índice con todos los artículos sobre MySQL!

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