lunes, 23 de julio de 2018

Variable lógica de control

Puede descargar el archivo booleanoPorDefecto.xlsm


Generamos siete números aleatorios entre 1 y 10 en las celdas del rango B4:H4. En la celda amarilla (B6) generamos otro número en el mismo rango y deseamos conocer si este valor se encuentra entre los siete números generados de la fila 4.

Veamos varias formas de abordar el caso práctico con macros de VBA para Excel.

Caso 1

El primer caso  imprime en la celda C6 la frase 'Se ha encontrado' cuando el valor de la celda B6 coincide con alguno de los siete números de la fila 4. En la fila 4 pueden darse valores repetidos como se puede ver en la imagen siguiente.



El inconveniente de este método reside en que cuando la celda amarilla no coincide con ninguno de los números de la fila 4, en la celda C6 no se imprime nada, ya que no se entra dentro del condicional if en ningún momento. Nos gustaría que si no encuentra coincidencia pusiera una frase indicando que así ha sido. Pero no podemos incluir en el condicional if un else ya que al analizar los siete números cada vez que uno de ellos no coincida con la celda amarilla escribiría la frase indicando que no coinciden. Esto supondría un funcionamiento incorrecto del código. Veamos el segundo caso donde esto se soluciona con la ayuda de una variable booleana.

Sub rastrea()
For i = 1 To 7
  Cells(4, i + 1) = Int(Rnd() * 10) + 1
Next i
n = WorksheetFunction.RandBetween(1, 10)
Range("B6") = n
Range("C6").ClearContents
For i = 1 To 7
  If Cells(4, i + 1) = n Then
    Range("C6") = "Se ha encontrado"
  End If
Next i
End Sub


Caso 2

El código de este caso parte del anterior si bien añade una variable lógica denominada distintos que se inicializa como True. Esto supone que de entrada supondremos que los valores son distintos. Por tanto, supondremos inicialmente que no existe coincidencia de valor entre la celda amarilla y las siete previas de la fila cuatro. Nos metemos en un bucle for que recorre las siete posiciones comprobando con un condicional if si existe coincidencia. Si se detecta alguna coincidencia la variable lógica distintos se torna en False. Finalmente, fuera del bucle, añadimos un nuevo condicional if que analizará si la variable booleana distintos es verdadera y en caso afirmativo imprimirá en la celda B6 la frase 'NO se ha encontrado'.
Observe que en el último condicional if no es necesario poner como condición distintos=True, ya que la variable lógica ya es en si misma True o False.




Sub analiza()
Dim distintos As Boolean
distintos = True
For i = 1 To 7
  Cells(4, i + 1) = Int(Rnd() * 10) + 1
Next i
n = WorksheetFunction.RandBetween(1, 10)
Range("B6") = n
Range("C6").ClearContents
For i = 1 To 7
  If Cells(4, i + 1) = n Then
    distintos = False
    Range("C6") = "Se ha encontrado"
  End If
Next i
If distintos Then
  Range("C6") = "NO se ha encontrado"
End If
End Sub

Caso 3

Este caso es una variante del anterior donde no usamos variable lógica. Lo que hacemos es escribir en la celda C6 de entrada, y como valor por defecto, la frase  'NO se ha encontrado'. Luego, si al analizar la coincidencia de valores se verifica que existe alguna coincidencia lo que se hace es reescribir esa celda con la frase 'Se ha encontrado'. Con este método lo que conseguimos es que si no se encuentra coincidencia de valores la frase inicialmente escrita es válida y se muestra en pantalla sin necesidad de añadirla porque ya existía desde un principio.

Sub noEncontradoPorDefecto()
For i = 1 To 7
  Cells(4, i + 1) = Int(Rnd() * 10) + 1
Next i
n = WorksheetFunction.RandBetween(1, 10)
Range("B6") = n
Range("C6") = "NO se ha encontrado"
For i = 1 To 7
  If Cells(4, i + 1) = n Then
    Range("C6") = "Se ha encontrado"
  End If
Next i
End Sub

Pasar argumentos por valor (ByVal) o por referencia (byRef) en VBA para Excel

Puede descargar el archivo ReferenciaValor.xlsm

En el lenguaje de programación VBA para Excel podemos elegir entre pasar parámetros o argumentos a las funciones o subprocedimientos por valor (ByVal) o por referencia (ByRef). Veremos las diferencias de ambos métodos y pondremos varios ejemplos.


  • ByVal. Cuando se pasa un parámetro por valor lo que se hace es enviar un número si la variable es numérica o un string si la variable es una cadena, o del tipo que sea. No son la misma variable la interna al subprocedimiento o función que la del procedimiento principal, por lo que al terminar el subprocedimiento y retornar el flujo del programa al procedimiento principal la variable no retorna con el valor con el que hubiera acabado el subprocedimiento. Al retornar al procedimiento principal la variable continúa valiendo lo mismo que valía cuando se envió como parámetro. Por ejemplo, si la variable i se envía como parámetro con el valor 5, y al terminar el subprocedimiento o función finaliza con el valor 10, al retornar al procedimiento principal la variable i continuará con el valor 5.
  • ByRef. Cuando se pasa un parámetro por referencia lo que hacemos es enviar una variable con un cierto valor, el que tenga en el momento del envío. Al retornar al procedimiento principal la variable viene con el valor con el que hubiera terminado en el subprocedimiento o función. Por ejemplo, si la variable i se envía como parámetro con el valor 5, y al terminar el subprocedimiento o función finaliza con el valor 10, al retornar al procedimiento principal la variable i vendrá con el valor 10.

Por defecto los parámetros en VBA se pasan ByRef



Caso 1

Disponemos de un procedimiento principal que contiene un bucle for que se repite cuatro veces. Dentro del bucle únicamente tenemos una línea de código que llama al subprocedimiento Saluda y le pasa el valor de i como parámetro.
El subprocedimiento Saluda recoge el parámetro i como valor (ByVal). Mediante un MsgBox mostrará en una pequeña ventana emergente un saludo diciendo Hola junto al valor de i, que será un número de 1 al 4. Luego, y dentro del subprocedimiento, se asigna a i el valor 100.

  • ByVal. Si pasamos el valor de i por valor, al lanzar el procedimiento principal la macro nos saludará cuatro veces y al final ejecutará la última línea del procedimiento principal y nos dirá que i es igual a 5.
  • ByRef. Si pasamos el valor de i por referencia, al lanzar el procedimiento principal únicamente nos saludará una vez diciendo Hola1, pero no seguirá con los siguientes ciclos del bucle for ya que la variable i vuelve con el valor 100. Como 100 es superior al límite dado en el bucle for que es cuatro, se considera que el bucle ha finalizado y por tanto se ejecutará la última línea del procedimiento principal que hace que se muestre en pantalla el valor 101.
 


Sub Principal_1()
For i = 1 To 4
  Call Saluda(i)
Next i
MsgBox (i)
End Sub
Sub Saluda(ByVal i)
  MsgBox ("Hola" & i)
  i = 100
End Sub



Caso 2

En el procedimiento principal asignamos a las variables x, y, z el valor 5. Imprimiremos su valor empleando para la variable x la columna A, para la variable y la columna B y para la variable z la columna C. Llamamos al subprocedimiento Dobla y le pasamos como parámetros los valores x, y, z.
El subprocedimiento Dobla recibe el parámetro x por referencia (ByRef), el parámetro y por valor (ByVal) y el parámetro z lo recibe sin indicar nada para ver cómo trata VBA por defecto los parámetros que se pasan a un subprocedimiento o función. Se dobla el valor de x, y, z. Se imprime nuevamente el valor de x, y, z en la fila dos de las columnas A, B, C respectivamente. Veremos que los valores impresos son 10, 10, 10, esto es así ya que estamos imprimiendo el valor de la variable interna del subprocedimiento y en los tres casos esta variable es el doble de cinco.
Finalizado el subprocedimiento se vuelve al procedimiento principal y en la fila tres se imprimen nuevamente los valores de x, y, z. Pero ahora vemos que lo que se imprime es 10, 5, 10. Veamos el motivo de esta diferencia.


  • ByRef. El parámetro x se pasó por referencia. Continúa siendo la misma variable la que se definió inicialmente en el procedimiento principal, la que luego se usa en el subprocedimiento y la que finalmente retorna al procedimiento principal. Al retornar, vuelve con el valor 10.
  • ByVal. El parámetro y se pasó por valor y por tanto lo que se hace es pasarlo como si fuera un número sin que quede vinculación con la variable inicialmente definida en el procedimiento principal. En el subprocedimiento se dobla el valor y para de 5 a 10, pero al retornar al procedimiento principal no se retorna ningún valor, y la variable y en el procedimiento principal sigue valiendo 5 que es tal y como se definió en un principio.
  • Por defecto. El parámetro z se pasó sin indicar nada y al final se ha comportado como la variable x. Esto indica que si no ponemos nada, por defecto VBA pasa los parámetros por referencia (ByRef).


Sub Principal_2()
x = 5: y = 5: z = 5
Cells(1, "A") = x: Cells(1, "B") = y: Cells(1, "C") = z
Call Dobla(x, y, z)
Cells(3, "A") = x: Cells(3, "B") = y: Cells(3, "C") = z
End Sub
Sub Dobla(ByRef x, ByVal y, z)
x = 2 * x: y = 2 * y: z = 2 * z
Cells(2, "A") = x: Cells(2, "B") = y:: Cells(2, "C") = z
End Sub



Caso 3

Queremos listar los números del 10 al 20. Disponemos de un procedimiento principal que llama a un subprocedimiento que se denomina Listado, al que se pasan dos parámetros a y b. El parámetro b se puede pasar por valor o por referencia. Si se pasa por valor la lista impresa se genera en vertical y si se pasa por referencia la lista impresa se muestra en diagonal.

En el procedimiento principal inicializamos la variable
b haciendo que su valor se igual a uno. Nos metemos en un bucle for donde la variable a varía entre 10 y 20. Dentro del bucle se llama al subprocedimiento Listado pasándole los parámetros a y b.

El subprocedimiento Listado escribe el valor de a en la fila a y columna b. Finalmente tiene una línea de código que incrementa el valor de b en una unidad.

  • ByRef. Si pasamos el parámetro b por referencia el incremento de la variable b en una unidad que se hace en la última línea de código se recordará en el procedimiento principal y por tanto la variable b en el primer ciclo del bucle for valdrá 1, pero en el segundo ciclo ya valdrá 2, en el tercero 3, y así sucesivamente. Esto hace que al ejecutar reiteradamente el subprocedimiento y escribir con cells cada vez se haga en una fila más a la derecha, lo que provoca que el resultado se vea en diagonal.
  • ByVal. Si pasamos el parámetro b por valor la última línea de código que hace que b se incremente en una unidad no se recordará al llegar la procedimiento principal y por tanto b continuará valiendo 1 que es el valor con el que se inicializó. Esto provoca que al ser b siempre igual a uno, no nos movamos de la columna uno, y por tanto la serie de números se imprima en vertical todos ellos en la columna uno.





Sub Principal_3()
b = 1
For a = 10 To 20
  Call Listado(a, b)
Next a
End Sub
Sub Listado(a, ByRef b)
Cells(a, b) = a
b = b + 1
End Sub



Caso 4

Vamos a calcular el montante final al que se llega aplicando la ley de capitalización compuesta con los siguientes datos.
Capital inicial C = 1.000 €
tipo de interés i = 0,15
tiempo años t = 3

Disponemos de un procedimiento principal que llama dos veces a la función Montante. En la función existe una última línea de código que hace que el valor del tipo de interés i se reduzca en un 5%.

  • ByRef. Si pasamos el parámetro i por referencia la primera vez el tipo de interés valdrá 15% y la segunda vez valdrá 10% ya que se ha reducido el valor del tipo de interés y el procedimiento principal toma ese valor ya que no olvida el último valor con el que quedó la variable. Esto provoca que los dos montantes sean diferentes, el primero calculado al 15% y el segundo al 10%.
  • ByVal. Si pasamos el parámetro i por valor la última línea del subprocedimiento no se recordará al llegar al procedimiento principal y por tanto el valor del tipo de interés no se reducirá y continuará siendo del 15%. Esto provoca que los dos montantes sean iguales, ambos calculados al 10%.




Sub Principal_4()
i = 0.15
t = 3
C = 1000
Cells(1, "H") = Montante(i, t, C)
Cells(2, "H") = Montante(i, t, C)
End Sub
Function Montante(ByVal i, t, C)
Montante = C * (1 + i) ^ t
i = i - 0.05
End Function

martes, 17 de julio de 2018

Bucles For anidados

Puede descargar el archivo BuclesForAnidados.xlsm

Vamos a trabajar con dos bucles For...Next anidados. Realizaremos unos ejercicios con macros Excel programando en VBA.

Llegaremos a realizar la siguiente figura con números que van entre 1 y 9, tanto en horizontal como en vertical.


Pero antes de llegar a obtener esa imagen que hemos denominado 'Bandera Color' vamos a ir paso a paso.



Borra

Como vamos a trabajar en varios casos, antes de comenzar  nos interesa borrar el contenido del rango A1.I9. También vamos a borrar el color de fondo de las celdas.


Sub Borra()
Dim R As Range
Set R = Range("A1:I9")
R.ClearContents
R.Interior.Pattern = xlNone
End Sub


Completo

Anidamos dos bucles For para conseguir imprimir en cada una de las celdas del cuadrado de 9 filas y 9 columnas, los números i j.



Sub Completo()
Dim i As Byte, j As Byte
Call Borra
For i = 1 To 9
  For j = 1 To 9
    Cells(i, j) = Str(i) & " " & Str(j)
  Next j
Next i
End Sub


Caja

Ahora queremos que no se imprima el cuadrado completo, únicamente deseamos imprimir los bordes. Para ello precisamos incluir dentro de los bucles anidados un condicional if que imprima únicamente los índices i j cuando se cumpla que el primero es igual a 1 o 9, o bien el segundo sea igual a 1 o 9. De esta forma conseguimos imprimir solo el perímetro del cuadrado.



Sub Caja()
Dim i As Byte, j As Byte
Call Borra
For i = 1 To 9
  For j = 1 To 9
    If i = 1 Or i = 9 Or j = 1 Or j = 9 Then
      Cells(i, j) = Str(i) & " " & Str(j)
    End If
  Next j
Next i
End Sub


Diagonal 1

Queremos imprimir únicamente la diagonal primera que se consigue haciendo que el condicional if filtre únicamente aquellos valores donde los índices i j coincidan.




Sub Diagonal_1()
Dim i As Byte, j As Byte
Call Borra
For i = 1 To 9
  For j = 1 To 9
    If i = j Then
      Cells(i, j) = Str(i) & " " & Str(j)
    End If
  Next j
Next i
End Sub


Diagonal 2

La segunda diagonal se consigue buscando qué tienen en común los índices i j. Observamos que esta diagonal cumple que al sumar ambos índices la suma siempre es igual a 10. Esta será la condición que impondremos en el condicional if.



Sub Diagonal_2()
Dim i As Byte, j As Byte
Call Borra
For i = 1 To 9
  For j = 1 To 9
    If i + j = 10 Then
      Cells(i, j) = Str(i) & " " & Str(j)
    End If
  Next j
Next i
End Sub


Bandera


Deseamos imprimir únicamente los bordes y las dos diagonales. A esta figura la hemos llamado bandera. Observe que se consigue incluyendo en el if seis condiciones concatenadas con el operador lógico Or.



Sub Bandera()
Dim i As Byte, j As Byte
Call Borra
For i = 1 To 9
  For j = 1 To 9
    If i = 1 Or i = 9 Or j = 1 Or j = 9 Or i = j Or i + j = 10 Then
      Cells(i, j) = Str(i) & " " & Str(j)
    End If
  Next j
Next i
End Sub


Bandera Color

Nos gustaría que la bandera tuviera colores. Los colores de fondo de cada celda se consiguen con Interior.ColorIndex=número. Donde el número nos da el color.





Sub BanderaColor()
Dim i As Byte, j As Byte
Call Borra
For i = 1 To 9
  For j = 1 To 9
    If i = j Or i + j = 10 Then
      Cells(i, j) = Str(i) & " " & Str(j)
      Cells(i, j).Interior.ColorIndex = 3 'rojo
    ElseIf i = 1 Or i = 9 Or j = 1 Or j = 9 Then
      Cells(i, j) = Str(i) & " " & Str(j)
      Cells(i, j).Interior.ColorIndex = 6 'amarillo
    Else
      Cells(i, j).Interior.ColorIndex = 8 'azul
    End If
  Next j
Next i
End Sub

Ya tenemos bandera.

lunes, 4 de junio de 2018

Triángulo de Floyd

Puede descargar el archivo trianguloFloyd.xlsm

El triángulo de Floyd para cuatro filas es el siguiente.


Se construye con los números naturales en forma de triángulo rectángulo. Se suele utilizar como ejercicio para los que están aprendiendo a programar en un cierto lenguaje.

El triángulo de Floyd se resuelve con un algoritmo que ideó el Dr. Floyd, científico e informático que fue compañero de habitación de Carl Sagan cuando ambos estudiaban en la universidad.

Hoja 1

Resuelto usando fórmulas de Excel y sin usar macros.



La fórmula de la celda C5 calcula el máximo de la fila anterior para saber con qué número se ha de comenzar la fila actual.

=MAX(C4:P4)+1

La celda D5 suma 1 al valor previo y usa un condicional SI para saber hasta que valor se ha de continuar sumando 1.

=SI(CONTAR($C5:C5)<$A5;C5+1;"")

Hoja 2

También resuelve el triángulo con fórmulas y sin usar macros.

En este caso las celdas de la primera columna se obtienen con una fórmula que indica que nos da el último valor de la fila precedente y le suma 1. Se cumple que los últimos valores de cada fila son los llamados números triangulares, que se obtienen como n*(n+1)/2. Siendo n el número de fila.


En nuestro caso la celda C5 tiene la siguiente expresión.

=(A5*(A5-1)/2)+1

La celda D5 se calcula con la siguiente fórmula, que es igual a la empleada en la Hoja1.

=SI(CONTAR($C5:C5)<$A5;C5+1;"")

Hoja3

Se construye el triángulo de Floyd mediante macro.


Sub Floyd1()
Dim n As Long, i As Long, j As Long, n_max As Long
Dim R As Range
Worksheets("Hoja3").Activate
Set R = Range("B3")
n_max = 24: j = 1
R.Offset(1, -1).Resize(n_max+2, n_max+2).ClearContents
For n = 1 To n_max
  R.Offset(n, -1) = n 'imprimimos la columna A
  For i = 1 To n 'i recorre los elementos de cada fila
    R.Offset(n, i) = j 'imprimimos el valor de j en la celda que toca
    j = j + 1  'j proporciona los números naturales correlativos
  Next i
Next n
End Sub


Hoja4

Dada una fila n, podemos calcular el último valor de su fila usando los números triangulares que son los siguientes.


  1. Para n=1 el número triangular es 1
  2. Para n=2 el número triangular es 3
  3. Para n=3 el número triangular es 6
  4. Para n=4 el número triangular es 10
  5. Para n=5 el número triangular es 15

A esos valores e le suma 1 para saber cuál es el primer valor de la fila siguiente.

Sub Floyd2()
Dim n As Long, i As Long, j As Long, n_max As Long
Dim R As Range
Worksheets("Hoja4").Activate
Set R = Range("B3")
n_max = 24
R.Offset(1, -1).Resize(n_max+2, n_max+2).ClearContents
For n = 1 To n_max
  R.Offset(n, -1) = n
  'primera columan del triángulo
  R.Offset(n, 1) = (n * (n - 1) / 2) + 1
  For i = 2 To n
    R.Offset(n, i) = R.Offset(n, i - 1) + 1
  Next i
Next n
End Sub

Hoja5


Una pequeña variante para poder elegir el número de filas desde un control numérico que se encuentra en la propia hoja de cálculo.


También está disponible en un lenguaje de programación que está muy de moda.

domingo, 3 de junio de 2018

Seleccionar tabla sin cabecera

Puede descargar el archivo seleccionaTabla.xlsm

Primero generamos una tabla con valores aleatorios y con un número de filas que podemos elegir, con un control numérico, entre 1 y 20.


La macro que genera la tabla con valores aleatorios es la siguiente.

Observe que se define la celda B4 como la esquina superior izquierda y en base a ella se genera toda la tabla. Esta esquina sería fácil de variar en el código de la macro, gracias al uso de Offset.

Sub generaTabla()
Dim n As Byte, i As Byte
Dim R As Range
Set R = Range("B4")
n = [I2]
Range("B5:F24").ClearContents
For i = 1 To n
  R.Offset(i, 0) = i
  R.Offset(i, 1).Value = WorksheetFunction.Choose(Int(Rnd() * 3) + 1, "Norte", "Sur", "Centro")
  R.Offset(i, 2).Value = Date - i + 1
  R.Offset(i, 3).Value = WorksheetFunction.Choose(Int(Rnd() * 3) + 1, "Libros", "Comic", "Web")
  R.Offset(i, 4).Value = (Int(Rnd() * 100000) + 20000) / 100
Next i
End Sub


El código VBA que selecciona la tabla sin incluir la cabecera es la siguiente.

Sub seleccionaTablaSinCabecera()
Worksheets("Hoja1").Activate
'el cursor inicialmente tiene que estar dentro de la tabla
Range("B5").Select
Set R = ActiveCell.CurrentRegion
R.Offset(1, 0).Resize(R.Rows.Count - 1, R.Columns.Count).Select
End Sub

Aquí vemos otro uso estupendo de Offset combinado con Resize, propiedad de los rangos que hemos visto recientemente. Puede verlo en el post siguiente.

viernes, 1 de junio de 2018

Árbol binomial generado con una macro

Puede descargar el archivo arbolBinomial.xlsm

Vamos a crear un árbol binomial usando una macro de Excel, con un poco de código VBA. Lo interesante del caso es que al variar el número de periodos n el árbol se recalcula y se redimensiona en tamaño.

Partimos de un precio de una acción de S=100 €. Este precio puede subir o bajar en cada periodo. Suponemos que si sube lo hará con incrementos del 25% (u=1,25) y si baja lo hace con disminución del 20% (d=0,80).

Se cumple que d=1/u

1 / 1,25 = 0,80

n=1


El árbol para un periodo sería el siguiente.


Donde
125 = 100 * 1,25
80 = 100 * 0,80

Partiendo del precio inicial de 100, transcurrido un periodo pueden suceder dos cosas, o bien, el precio se incrementa y 25% pasando a ser 125 €, o bien se reduce un 20% pasando a ser 80 €.

n=2

Si hacemos el árbol para dos periodos.


Donde
156,25 = 125 * 1,25
100 = 125 * 0,80  o bien  100 = 80 * 1,25
64 = 80 * 0,80

Para el periodo 2, el valor mayor  (156,25) se obtiene incrementando un 25% más el precio superior del periodo anterior. También se puede ver como que 156.25 = 100 * 1,25 * 1,25, ya que se parte de un precio inicial de 100 y se experimentan dos incrementos del 25%.

El valor de 100 € del periodo 2 se alcanza por uno de los dos siguientes caminos.
  • 100 = 100*1,25*0,80 Partimos de 100, subimos a 125 y luego volvemos a bajar a 100.
  • 100 = 100 *0.80*1,25. Partimos de 100, bajamos a 80 y luego volvemos a subir a 100.
El valor de 64 se puede entender que se alcanza partiendo del precio inicial de 100 y experimentando dos reducciones consecutivas del 20%. 64 = 100 * 0,80 * 0,80

n=3

Si hacemos el árbol para tres periodos.


Donde
195,3125 = 100 * 1,253
125 = 100 * 1,252 * 0,80
80 =  100 * 1,25 * 0,802
51,2 = 100 * 0,803

Para n>3

La macro funciona hasta n=40, y no por la limitación de la propia macro sino porque hemos limitado hasta 40 el valor que se puede poner en la celda amarilla (C7) usando el control numérico que está a su lado.



Option Explicit
Public n As Integer 'número de etapas del arbor, hasta 40
Public A() As Double 'matriz que contiene el arbol

Sub arbol()
Dim i As Integer, j As Integer
Dim u As Double, d As Double
Worksheets("Hoja1").Activate
n = [C7]: u = [C4]: d = [C5]
Call borra
Call cabeceras
ReDim A(2 * n, n) 'el arbol tiene el doble de filas que de columnas
A(n, 0) = 100 'valor inicial en la columna cero
For j = 1 To n  'columnas de la matriz
  For i = 0 To 2 * n 'filas
    If j = n - i Then 'primero calculamos la diagonal superiro
      A(n - j, j) = A(n - j + 1, j - 1) * u
    ElseIf j >= n - i + 2 And j <= i + n Then 'calculamos el resto
      A(i, j) = A(i - 1, j - 1) * d
    End If
  Next i
Next j
Call imprimeA
End Sub
Sub borra()
Range("C10:AR91").Clear ' borra hasta n=40
End Sub
Sub cabeceras()
Dim i As Integer
Range("A1").Copy ' copiamos A1 para luego pegar el formato
'pegamos el formato de A1 a la columna C
Range(Cells(10, "C"), Cells(2 * n + 11, "C")).PasteSpecial Paste:=xlPasteFormats
'pegamos el formato de A1 a la fila 10
Range(Cells(10, 4), Cells(10, n + 4)).PasteSpecial Paste:=xlPasteFormats
Application.CutCopyMode = False 'elimina la fila de hormigas
For i = 0 To n
  'generamos los números 0 a 2n de la columna C
  Cells(i + 11, 3) = i 'vertical, los n primeros
  Cells(i + n + 11, 3) = i + n 'vertical, los n últimos
  'generamos los números 0 a n de la fila 10
  Cells(10, i + 4) = i 'horizontal
Next i
Range("C10").Activate 'situamos el cursor en C10
End Sub
Sub imprimeA()
Dim i As Integer, j As Integer
For j = 0 To n
  For i = 0 To 2 * n 'recorremos toda la matriz A
    If A(i, j) <> 0 Then 'imprimimos solo los no vacios
      Cells(i + 11, j + 4) = A(i, j)
    End If
  Next i
Next j
End Sub

La idea básica para hacer el árbol es que la diagonal superior se obtiene como el precio anterior por u. Y el resto de los valores del árbol se obtienen como el precio superior del periodo anterior por d.

Ejemplo para n=4.


244,1 se obtiene como 195,3 * 1,25
El resto de valores se obtienen multiplicando por 0,80, así tenemos los siguientes.
156,3 = 195,6 * 0,80
100 = 125 * 0,80
64 = 80 * 0,80
40,96 = 51,2  * 0,80

Este es método que usa la macro para obtener todos los valores del árbol binomial.

Lo que más esfuerzo ha costado es calcular bien las celdas donde se han de escribir los valores del árbol ya que al crecer n el árbol va aumentando de tamaño y es necesario ir bajando la celda inicial.

jueves, 31 de mayo de 2018

Manejar matrices con VBA

Puede descargar el archivo manejarMatrices.xlsm

Vamos a trabajar con matrices en Excel programando en VBA (Visual Basic for Applications).


Lo interesante de este caso es ver que para dejar el contenido de una matriz en la hoja de cálculo lo que debemos hacer es lo que nos dice la intuición.

Rango = Matriz 'respetando las dimensiones


Option Base 1 'Las matrices empiecen en 1 y no en 0

Sub manejaMatriz()
Dim A As Variant
Dim B As Variant
'para asignar un rango a una matriz
A = Range("B4:E9")
'para asignar una matriz a un rango
B = WorksheetFunction.Transpose(A)
'para imprimir una matriz en un rango
Range("B11:G14") = B
End Sub

Sub aleatorios()
Dim A(6, 4) As Double
Dim inicio As Range
Dim final As Range
Randomize 'para mejorar la aleatoriedad
For i = 1 To 6
  For j = 1 To 4
    'números aleatorios [0,1) a dos decimales
    A(i, j) = Int(Rnd() * 100) / 100
  Next j
Next i
Set inicio = Cells(4, "B")
Set final = Cells(9, "E")
Range(inicio, final) = A
End Sub

Sub multiplicaMatriz()
Dim A() As Variant
Dim B() As Variant
Dim C() As Variant
A = Range("B4:E9")
B = Range("B11:G14")
C = WorksheetFunction.MMult(A, B)
Range("B16:G21") = C
End Sub

Sub invierteMatriz()
Dim A() As Variant
A = Range("B23:D25")
Range("B27:D29") = WorksheetFunction.MInverse(A)
Range("B27:D29").Interior.Color = 6750156
Call extraeElementos
End Sub

Sub extraeElementos()
Dim A() As Variant
Dim origen As Range
Range("M4:AC30").Clear
Range("M4:AC30").Interior.Color = 13434879 'amarillo
Set origen = Range("L3")
A = Range("B27:D29")
fila = [L14]
columna = [S2]
For i = 1 To 3 'recorremos las 3 filas de la matriz
  For j = 1 To 3 'recorremos las 3 columnas de A
    With origen.Offset(fila + i - 1, columna + j - 1)
    .Value = A(i, j)
    .Borders(xlEdgeLeft).LineStyle = xlContinuous
    .Borders(xlEdgeRight).LineStyle = xlContinuous
    .Borders(xlEdgeTop).LineStyle = xlContinuous
    .Borders(xlEdgeBottom).LineStyle = xlContinuous
    End With
  Next j
Next i
Range(origen.Offset(fila + i - 4, columna + j - 4), origen.Offset(fila + i - 2, columna + j - 2)).Interior.Color = 6750156
End Sub

Sub copia()
Dim A As Variant
A = Range("B4:D6")
Range("B23:D25") = A
Range("B4:D6,B23:D25").Interior.ColorIndex = 8
End Sub

Sub Borra()
Range("B4:AD32").ClearContents
[S2] = 1: [L14] = 1
Range("B4:G29").Interior.Pattern = xlNone
Range("M4:AC30").Clear
Range("M4:AC30").Interior.Color = 13434879 'amarillo
End Sub

También es interesante ver el pos siguiente.

Propiedad Resize para manejar rangos en Excel

Puede descargar el archivo resize.xlsm

Cuando programamos macros en Excel usando VBA es muy habitual trabajar con rangos. Una propiedad de los rangos que modifica su tamaño es resize.

Rango.Resize(filas, columnas).Select

Veamos algunos ejemplos de su uso.



Resize1

Da color aleatorio a las celdas del rango B4:E8.

Sub Resize1()
Dim rojo As Byte, verde As Byte, azul As Byte
Dim R As Range
Set R = Range("B4")
Range("A1").Select
Randomize 'elegimos colores aleatorios
rojo = Int(Rnd() * 100) + 100
verde = Int(Rnd() * 100) + 100
azul = Int(Rnd() * 100) + 100
R.Resize(5, 4).Interior.Color = RGB(rojo, verde, azul)
End Sub

Observe que después de Resize(5.4) se ha de poner algo, o bien, .Select para seleccionar, o bien, .Interior.Color=RGB(rojo, verde, azul) como en este caso. Pero si después de Resize se deja sin poner nada nos dará error.

Resize2

Permite seleccionar un rango de 3 filas y 2 columnas usando como celda de origen la B4.

Range("B4").Resize(3, 2).Select



Sub Resize2()
'Seleccionamos un rango de 3 filas y 2 columnas
'La celda de origen es B4
Range("B4").Resize(3, 2).Select
End Sub

Resize3

Permite seleccionar un rango de 3 filas en la primera columna usando como celda de origen la B4.

Range("B4").Resize(3).Select



Sub Resize3()
'Seleccionamos un rango de 3 filas de la primera columna
'La celda de origen es B4
Range("B4").Resize(3).Select
End Sub

Resize4

Permite seleccionar un rango de 3 columnas en la primera fila usando como celda de origen la B4.

Range("B4").Resize(, 3).Select




Sub Resize4()
'Seleccionaremos un rango de 3 columnas de la primera fila
'La celda de origen es B4
Range("B4").Resize(, 3).Select
End Sub

Resize5

Permite seleccionar un rango de 2 columnas en la primera fila usando como celda de origen la B4 y hasta la fila 8, ya que el rango indicado es hasta la E8.

Range("B4:E8").Resize(, 2).Select



Sub Resize5()
Range("B4:E8").Resize(, 2).Select
End Sub

Resize6

Permite seleccionar un rango de 3 columnas en la primera fila usando como celda de origen la A4.

Range("B4").Offset(, -1).Resize(, 3).Select

Es una maravilla poder usar Offset para cambiar el rango de referencia, y usar, como en el ejemplo, valores negativos. Esto aporta flexibilidad al manejar gran cantidad de rangos cambiantes.


Sub Resize6()
Range("B4").Offset(, -1).Resize(, 3).Select
End Sub

Resize7

Copia el rango amarillo (B11:E15) en el rango superior (B4:E8).

Range("B4").Resize(5, 4) = A

Este es un uso muy útil de la propiedad Resize ya que nos permite depositar (imprimir) de golpe todo un rango o el contenido de una matriz.



Sub Resize7()
Dim A As Variant
Worksheets("Hoja1").Range("A1").Select
A = Range("B11:E15")
Range("B4").Resize(5, 4) = A
End Sub

Resize8

Hace lo mismo que la macro anterior, copia el rango amarillo (B11:E15) en el rango superior (B4:E8).

Range("B4").Resize(R.Rows.Count, R.Columns.Count) = A

Este procedimiento realiza el mismo trabajo que el anterior aunque lo hemos programado de otra forma. En este caso, creamos las variables n y m que calculan el número de filas y columnas respectivamente del rango R. De esta forma hacemos más flexible el código ya que evitamos tener que dar nosotros los parámetros a la propiedad Resize.

Sub Resize8()
Dim A As Variant
Dim R As Range
Worksheets("Hoja1").Range("A1").Select
Set R = Range("B11:E15")
A = R
n = R.Rows.Count
m = R.Columns.Count
Range("B4").Resize(n, m) = A
End Sub

Resize9

Genera una matriz de números aleatorios y la imprime en una posición inicial variable y con un tamaño variable.

Range(Cells(pf, pc), Cells(pf, pc)) .Resize(n, m) = A


Seguidamente se muestra el código de ejemplo utilizado para ilustrar la versatilidad de la propiedad Resize.

Sub Resize9()
Dim A As Variant
Dim R As Range
Dim tf As Byte, tc As Byte, pf As Byte, pc As Byte
Worksheets("Hoja2").Activate
Range("E7:AQ45").Clear
Randomize
Range("A1").Select
tf = Int(Rnd() * 20) + 1 'tamaño:fila
tc = Int(Rnd() * 20) + 1 'tamaño: columna
pf = Int(Rnd() * 20) + 7 'posición inicial: fila
pc = Int(Rnd() * 20) + 5 'posición inicial: columna
[C6] = tf
[D6] = tc
[C5] = pf
[D5] = pc
Set R = Range(Cells(pf, pc), Cells(pf + tf - 1, pc + tc - 1))
R.Interior.Color = RGB(0, 255, 100)
A = R
n = R.Rows.Count
m = R.Columns.Count
ReDim A(n, m)
For i = 1 To n
  For j = 1 To m
    A(i, j) = Int(Rnd() * 100)
  Next j
Next i
Range(Cells(pf, pc), Cells(pf, pc)).Resize(n, m) = A
End Sub

Veamos un GIF animado donde se aprecia que el rango varía en posición y tamaño de forma aleatoria.


Conviene ver cómo se resolvió en otros casos la necesidad de imprimir de golpe toda una matriz, incluso de gran tamaño. Recomiendo ver los siguientes enlaces a otros post publicados.

domingo, 13 de mayo de 2018

Puntos linealmente separables

Puede descargar el archivo separarPuntos.xlsm

Vamos a generar 1000 puntos en un plano cartesiano unos rojos y otros azules. Las coordenadas de los puntos se generan de forma aleatoria pero lo que diferencia su color es que pueden ser separados por una línea recta.


Disponemos de una macro que genera los puntos y los parámetros de la recta en su forma implícita. La macro se denomina nuevaRecta y se lanza con un botón con el mismo nombre.


La ecuación implícita de la recta es la siguiente.

ω+ ωx+ ωx= 0

De ella despejamos la variable dependiente y obtenemos la ecuación explícita de la recta.

x= - (ω1 /  ω2) x1 - (ω0 / ω2)

Los parámetros que manejaremos para obtener la recta son ω0, ω1, ω2.

La macro que genera los puntos y la recta de forma aleatoria es la siguiente.

 Sub nuevaRecta()  
 Dim i As Integer  
 Dim R1 As Range, R2 As Range  
 Dim A, B  
 Set R1 = Range("B40:B1039")  
 Set R2 = Range("C40:C1039")  
 A = R1  
 B = R2  
 Randomize  
 For i = 1 To 1000  
  A(i, 1) = Rnd() * 10 - 5  
  B(i, 1) = Rnd() * 10 - 5  
 Next i  
 R1 = A  
 R2 = B  
 [C35] = Int(Rnd() * 80 - 40) / 10 'w0  
 [C36] = Int(Rnd() * 80 - 40) / 10 'w1  
 [C37] = Int(Rnd() * 80 - 40) / 10 'w2  
 End Sub  

Esta recta generada de forma aleatoria no separa bien los puntos rojos y azules, por lo que será necesario recurrir a algún procedimiento que nos de una nueva recta que si separe los puntos por colores.

Para conseguir separar los puntos mediante una recta procedemos a calcular en la celda amarilla (Q12) el número de errores cometidos. Cada punto rojo que esté por debajo de la recta y cada punto azul que esté por encima de la recta supondrán un error.


Para conseguir que el número de errores sea cero y que por tanto los puntos rojos queden por encima de la recta y los azules por debajo, recurrimos a una fantástica herramienta de Excel denominada 'Tabla de datos' que podemos encontrar en Datos / Análisis de hipótesis /Tabla de datos.


Lo que hacemos es calcular el error mínimo que se comete según diferentes valores de los parámetros de la recta ω0, ω1, ω2. La macro que se lanza con el botón 'mínimos' realiza la búsqueda de los errores mínimos. Este botón se ha de lanzar varias veces hasta conseguir que el error (celda amarilla) sea cero.

Este es un ejemplo que muestra la potencia de la herramienta Tabla de datos.

Veamos un gif animado donde se generan nuevos puntos y una nueva recta pulsando sobre el botón que llama a la macro nuevaRecta y luego pulsamos reiteradamente sobre el botón mínimos que lanza la macro que va minimizando los errores hasta que el error de la celda amarilla se hace cero. En ese momento tendremos la recta que separa completamente los puntos de colores en el plano.


viernes, 11 de mayo de 2018

Máquina de Galton en Excel

Puede descargar el archivo maquinaGalton.xlsm

La máquina de Galton nos permite ver cómo una distribución binomial tiende a una distribución normal cuando el número de tiradas va creciendo.


La máquina se puede ver en algunos museos de ciencias. También podríamos construirla nosotros con un tablero inclinado con una ranura superior por la que van cayendo bolitas que rebotan en una serie de clavos o pivotes. En cada rebote la bola tiene probabilidad 1/2 de ir hacia la izquierda o hacia la derecha. Esto se repite una y otra vez hasta que al final la bola termina en una cierta posición y cae por un carril que hemos construido con unas tablas verticales para separar unos de otros. Lo que vemos, si lanzamos un gran número de bolitas, es que los carriles de abajo forman una campana de Gauss. La distribución normal se forma como si de un histograma de frecuencias se tratara.

Vamos a construir una máquina de Galton virtual utilizando Excel y una macro que nos permite hacer el trabajo de la iteraciones de una forma rápida.

Hoja1

Primero creamos la macro que hace la que bolita baje rebotando entre los pivotes. En cada movimiento hacia abajo la bola tiene una probabilidad del 50% de ir hacia la izquierda y otro 50% de ir hacia la derecha. Es similar a un árbol binomial.



La macro que hace que la bola baje es la siguiente.

 Sub baja()  
 'árbol binomial de 32 etapas  
 Dim col As Byte  
 Worksheets("Hoja1").Activate  
 Randomize  
 Range("B2:BN68").Font.Bold = False  
 col = 34  
 Cells(2, 34) = "O"  
 Cells(4, 34) = "O"  
 Cells(4, 34).Font.Bold = True  
 For i = 1 To 32  
  If Rnd < 0.5 Then  
   col = col - 1  
  Else  
   col = col + 1  
  End If  
  Cells(i * 2 + 4, col) = "O"  
  Cells(i * 2 + 4, col).Font.Bold = True  
 Next i  
 End Sub  

Hoja2

Creamos un bucle FOR...NEXT que lanza un gran número de bolas, por ejemplo, 1000. De esta forma podemos ver en que columna ha quedado cada una de ellas al realizar el recorrido hacia abajo.

Veamos el código, similar al anterior pero incluyendo el bucle.

 Sub baja2()  
 Call BorraO  
 'árbol binomial de 32 etapas  
 Dim n As Long 'nº de tiradas  
 Dim col As Byte  
 Worksheets("Hoja2").Activate  
 Randomize  
 n = 1000  
 Application.ScreenUpdating = False  
 For j = 1 To n  
  col = 34  
  Cells(2, 34) = "O"  
  Cells(4, 34) = "O"  
  For i = 1 To 32  
   'una forma alternativa de sumar o restar 1 de forma aleatoria  
   col = col + WorksheetFunction.RandBetween(0, 1) * 2 - 1  
   Cells(i * 2 + 4, col) = "O"  
  Next i  
  'anotamos en la fila 99 los resultados  
  Cells(99, col) = Cells(99, col) + 1  
 Next j  
 Application.ScreenUpdating = True  
 End Sub  

Este es un proceso que puede tardar bastante tiempo en función del valor que demos a n. Para intentar reducir el tiempo de proceso podemos incluir al inicio la siguiente línea.

Application.ScreenUpdating = False


Con ella lo que hacemos el anular el envío de refresco a la pantalla de nuestro ordenador. Al final de la macro, dejamos el refresco activado para poder ver el resultado.

Application.ScreenUpdating = True

Veamos el resultado tras lanzar 10.000 veces la bola.



Hoja3

Nos gustaría poder ver la campana de Gauss que se forma con las tiradas. En la Hoja3 hemos creado unas columnas que se van rellenando con las bolas en vertical hasta que la columna más alta llegue a una altura de 30 bolas.


Con algo de imaginación podemos ver el bosquejo de una campana de Gauss. Para que veamos algo que nos recuerde más a la curva de una distribución normal tendríamos que usar muchas más tiradas.

Veamos el código.

 Sub baja3()  
 'árbol binomial de 32 etapas  
 Dim col As Byte  
 Call BorraO  
 Worksheets("Hoja3").Activate  
 Randomize  
 Do  
  col = 34  
  Cells(2, 34) = "O"  
  Cells(4, 34) = "O"  
  For i = 1 To 32  
   If Rnd < 0.5 Then  
    col = col - 1  
   Else  
    col = col + 1  
   End If  
   Cells(i * 2 + 4, col) = "O"  
  Next i  
  Cells(99, col) = Cells(99, col) + 1  
  miMax = Application.WorksheetFunction.Max(Range("Z99:AP99"))  
  Call BorraTri  
  Cells(98 - Cells(99, col), col) = "O"  
 Loop While miMax < 30  
 End Sub  


Hoja4 y Gráfico

En la Hoja4 lo que hacemos es traernos los valores obtenidos en la Hoja2, y presentarlos en forma de columna. Para ello usamos la siguiente expresión en la celda C4.

=INDIRECTO("Hoja2!"&"F99C"&B4*2;0)

Podemos ver aquí un potente uso de la función indirecto que toma valores de otra hoja para trasponerlos.

Con los valores obtenidos hacemos un histograma de frecuencias que se asemeja a una campana de Gauss. La apariencia será tanto mejor cuanto mayor sea el valor de tiradas (n).



jueves, 3 de mayo de 2018

Pesos y umbrales

Puede descargar el archivo pesosUmbrales.xlsm

He leído el siguiente artículo que es una introducción a la inteligencia artificial.


En el artículo se plantea un caso sencillo que podría resolver un perceptrón. Se trata de entender el comportamiento de una única neurona que tiene dos entradas con sus pesos omega 1 (ω1) y omega 2 (ω2), y un umbral de activación.

Planteamiento del problema

Un profesor realiza dos exámenes y pone la calificación final sin explicar cómo ha obtenido ésta. En la calificación final únicamente dice si el alumno ha aprobado o ha suspendido. Los alumnos desean averiguar que pesos da el profesor en cada examen (ω1 y ω2) para obtener la calificación media y con que nota media aprueba el profesor. Esa nota de corte sería el umbral de activación. Por ejemplo, una respuesta al problema podría ser la siguiente.

ω1=0,30 → El primer examen pesa un 30% en la nota final
ω2=0,70 → El segundo examen pesa un 70% en la nota final
u=0,4 → La asignatura se aprueba con un 4

Los pesos ω1 y ω2 se expresan en tanto por uno y su suma siempre es 1, que equivale al 100%.
La notas de los exámenes van entre 0 y 10, pero se divididen entre 10 para que su rango de variación esté entre 0 y 1. Lo mismo sucede con el umbral de activación (u), también se divide entre 10, por lo que aprobar con un 4 equivale a tener un umbral de 0,4.

Solución en Excel

No vamos a plantear la resolución en Excel mediante el uso de redes neuronales. Simplemente pretendemos plantear este caso sencillo mediante el uso de la hoja de cálculo. Es una pequeña aproximación a los fundamentos que rigen el comportamiento de una única neurona en un perceptrón sencillo de una capa. En lugar de ir buscando el camino más apropiado para llegar a la solución lo que hacemos es explorar todos los casos dentro de los valores que damos a ω1, ω2 y u.


Hacemos variar ω1 entre 0 y 1 en intervalos de 0,1. Como ω2 es la parte complementaria (ambas omegas suman 1), obtendremos que ω2 varía en el mismo intervalo, pero justo en orden inverso.

Hacemos variar el umbral u entre 0,1 y 0,9 con intervalos de 0,1.

Paso 1

Disponemos en la Hoja1 de los datos de los exámenes. Tenemos una tabla con las calificaciones obtenidas por los alumnos en el examen 1 y en el examen 2 (columnas C y D). En color naranja tenemos los pesos que ha asignado el profesor a cada examen y la nota de corte o umbral utilizado para aprobar.


Nuestro sistema será alimentado con los valores de color rosa correspondientes a 30 alumnos. Las columnas G y H contienen las notas de los dos exámenes divididas entre 10, ya que al perceptrón se le alimenta con datos estandarizados que van entre 0 y 1. La columna I indica si se ha aprobado el examen (1) o se ha supendido (0). La columan I es la misma que la columan F.



Paso 2

A la Hoja2 llevamos las notas de 30 alumnos, para ello copiamos y pegamos con pegado especial valores las tres columnas de color rosa.



Para cada uno de los 30 alumnos vamos a calcular la nota final ponderando con los valores de ω1y ω2 que van entre 0 y 1 con variación de 0,1. De esta forma se crea una tabla en las columnas de la E hasta la O. Así, la fórmula de la celda E7 es la siguiente fórmula matricial.

=SUMAPRODUCTO(TRANSPONER(E$4:E$5);$B7:$C7)

Esta fórmula multiplica la nota del examen 1 por el peso ω1 más el producto de la nota 2 por el peso ω2. También podríamos haber conseguido el mismo resultado con la fórmula siguiente para la celda E7.

=$B7*E$4+$C7*E$5



Paso 3


En las columnas desde la P hasta la Z, vamos a calcular la calificación de aprobado (1) o suspenso (0) teniendo en cuenta la nota media calculada en la tabla anterior y el umbral (u) que se encuentra en la celda P2. Si el umbral es 0,4 quiere decir que se aprueba con un 4 en la nota media.



La fórmula de la celda P7 es un condicional que nos dice si se aprubeba o no según se supere o no el umbral.

=SI(E7>=$P$2;1;0)


Paso 4

Ahora vamos a calcular los errores cometidos comparando el vector de ceros y unos de cada una de las columnas P:Z con los valores de la columna D que contienen los aprobados y suspensos publicados por el profesor.



La celda AA7 contiene la siguiente fórmula que nos permite realizar la comparación .

=--(P7<>$D7)

Si obtenemos un vector completamente de ceros lo vamos a colorear en amarillo usando Formato condicional.

En la fila 1, en el rango AA1:AK1 calculamos la suma de los errores cometidos en cada una de la columnas. Lo que nos interesa es detectar que el error sea cero. En AN1 calculamos el mínimo de ese rango y si llegamos a obtener un cero quiere decir que estamos ante un caso donde los valores de ω1, ω2 y u explican bien las calificaciones publicadas por el profesor.

Pero tenemos que calcular esta tabla para cada uno de los posibles valores de u desde 0,1 hasta 0,9. Para realizar este cálculo sin tener que ir variando el valor de forma manual o sin tener que hacer más tablas hemos recurrido a una estupenda herramienta de Excel denominada Tabla de datos y su resultado se muestra en el rango AM6:AN17.

Con ayuda de Formato condicional para los colores y con un par de botones que lanzan macros, podemos obtener la solución que buscamos. Si en el rango AP6:AP9 obtenemos las cuatro celdas con valores VERDADERO quiere decir que hemos encontrado la solución a un caso.

Si deseamos hacer un nuevo caso pulsaremos el botón denominado "cambia pesos" que lo que hace es cambiar los valores de los omegas y el umbral en la Hoja1, y lanzando la macro que intenta resolver el caso. El caso queda resuelto cando obtenemos los cuatro verdaderos.

Pero existe la posibilidad de que las 30 notas de los alumnos no sean suficientes para resolver el caso y entonces necesitemos otra muestra de valores. Esto se consigue pulsando el botón "Toma datos", que habrá que pulsar reiteradamente en algunas ocasiones para llegar a conseguir los cuatro verdaderos y por tanto la solución final del problema planteado.