Xwork's Blog

 Hola de nuevo a todos, el día de hoy solo vamos a platicar un poco.

Cómo muchos sabrán, la situación del mundo se complico a finales del año 2019 e inicios del 2020, pero se complico aun más en marzo, por lo que ya ha pasado mas de un año. Para todos fue un problema y más si perdimos a alguien. El tiempo ha pasado, y si bien no mencioné nada (y trate de no hacerlo, ya que había información de sobra) es importante que las cosas ya van mejorando.

Hay mucho que celebrar. La primera es que si estas leyendo esto, significa que casi la libramos ya (eso dependiendo de que país seas, pero por lo general). La segunda cosa es que en junio cumplimos cinco años y he estado trabajando para terminar los proyectos que quiero publicar y finalmente, también parece ser que el blog alcanzará sus primeras cien mil visitas en el mes de junio por lo que decidí hacer una buena tanda de post para ese mes.

Hace algún tiempo pensé en hacer alguna clase de cooperación con algunos de los blogs que surgieron casi al mismo tiempo que el mío, pero para mala suerte de todos, todos ellos desaparecieron.

Y bien, por ahora es todo.

Los leo luego

 Hola de nuevo a todos, el dia de hoy vamos a continuar con un poco mas de programación en Pascal. EN alguno de los post anteriores, vimos cómo usar arreglos, arreglos de punteros,  pero nos falto ver cómo usar arreglos dinámicos y arreglos de dimensiones múltiples. Si bien ya los usamos en los arreglos de punteros, no hemos visto aun cómo son la reglas para usarlos.

Arreglos de una sola dimensión.

type
	MiArr = array [0..9] of integer;
var
    Lista : MiArr;

program Arreglos;

type
ArregloDeNumeros = array[0..99] of integer;

var
MisNumeros : ArregloDeNumeros;
i : integer;

begin

    for i := 0 to 99 do
    begin 
        MisNumeros[i] := i * 2;
    end;
    
    for i := 1 to 99 do
    begin 
        writeln(MisNumeros[i]);
    end;
    
end.

Arreglos multidimensionales.

type
	MiArr = array [0..9 , 0..9] of integer;
var
    Lista : MiArr;

program ArreglosMulti;

type
ArregloDeNumeros = array[0..9 , 0..9] of integer;

var
MisNumeros : ArregloDeNumeros;
i , j : integer;

begin

    for i := 0 to 9 do
    begin 
    for j := 0 to 9 do
        MisNumeros[i,j] := i + j * 2;
    end;
    
    for i := 1 to 9 do
    begin 
        for j := 0 to 9 do
        write(' ',MisNumeros[i,j]);
        writeln();
    end;
	
end.

program ArreglosMulti;

type
ArregloDeNumeros = array[0..9 , 0..9, 0..9] of integer;

var
MisNumeros : ArregloDeNumeros;
i , j , k : integer;

begin

    for i := 0 to 9 do
    begin 
        for j := 0 to 9 do
        begin
            for k := 0 to 9 do
                MisNumeros[i , j , k] := i + j + k * 2;
        end;
    end;
    
    for i := 1 to 9 do
    begin 
        for j := 0 to 9 do
        begin
            for k := 0 to 9 do
            write(' ',MisNumeros[i,j,k]);
            
        writeln();
        end;
        writeln();
    end;

end.

Arreglos dinámicos.

program ArreglosDina;

type
ArregloDeNumeros = array of integer;

var
MisNumeros : ArregloDeNumeros;
i , Items : integer;

begin

    Items := 10;
    setlength(MisNumeros , Items);
    
    for i := 0 to (Items - 1) do
            MisNumeros[i] := i * 2;

    for i := 0 to (Items - 1) do
            writeln(' ',MisNumeros[i]);

end.

Hola de nuevo a todos, el día de hoy vamos a continuar con mas partes para llegar a la versión final del velocímetro.

Leyendo algunos comentarios que hace la gente sobre que más se le podría modificar al velocímetro, muchos de ellos coincidían que había que corregir algunos de ellos. Los principales "detalles" estaban en la pantalla. Si bien no eran errores, aprovechando que se va a actualizar, decidí arreglarlos de una vez.

Supongamos que en la pantalla tenemos una velocidad de 10.09 km/h pero si desaceleramos, a por ejemplo 9.1 la pantalla mostraba algo cómo 9.19, y la cosa era peor si nos deteníamos ya que se mostraba 0.09. La razón por la que pasaba esto es por cómo se maneja la pantalla. Para ponerlo de forma simple, solo cuando se escribe algo en cierta posición, la pantalla se actualiza pero solo en esa zona, cuando escribimos "v=10.09" se usan siete espacios y mientras los usemos con números que usen el mismo "ancho" no se verá ningún problema, pero cuando tenemos cualquier número inferior a 10.00 cómo 9.9 ahora solo se usan menos espacios por lo que en lugar de actualizar los mismos siete de antes, solo se actualizan cinco o seis. Para poder solucionarlo, podemos escribir número que si importar cual sea, siempre ocupen la misma cantidad de espacios.

En C existen varias formas de formatear números, pero algunas de ellas no están disponibles para usarse en arduino (y debo de admitirlo, eso no lo sabia hasta apenas) y por eso veremos cómo es posible usar el reemplazo que arduino ofrece.

Primero que nada, hay que definir cual es el "estilo" que queremos que cada número tenga. En el caso del velocímetro, hay cuatro números importantes: la velocidad, la distancia, las revoluciones (o vuletas) y el voltaje de la batería. En el caso de la velocidad, una velocidad máxima de 99.99km/h es mas que suficiente para una bicicleta por lo que el numero ocuparía cinco espacios (con el punto incluido). Para las distancia, un viaje de 999.99 km es mas que suficiente para la mayoría de los ciclistas, por lo que seis digitos parecen suficiente, para las revoluciones, 999999 parecen suficientes por lo que seis espacios parecen suficientes y finalmente la batería, ya que el voltaje máximo de una sola pila es 4.2v, con solo reservar tres espacios es mas que suficiente.

Ahora veamos un código hipotético en C que serviría para usarse en un programa de computadora (por ejemplo) pero que no produciría el resultado esperado en arduino. EL código es el siguiente:

#include <stdio.h>

float Speed = 9.1;
float Distance = 9.04;
int Revolution = 16384;
float Battery = 2.0;

char BuffSpeed[20];
char BuffDistance[20];
char BuffRevolution[20];
char BuffBattery[20];

int main()
{

    sprintf(BuffBattery , "R=%3.1f\n", Battery);
    sprintf(BuffRevolution , "R=%6d\n", Revolution);
    sprintf(BuffDistance , "d=%6.2f\n", Distance);
    sprintf(BuffSpeed, "V=%5.2f\n", Speed);

    printf(BuffSpeed);
    printf(BuffDistance);
    printf(BuffRevolution);
    printf(BuffBattery);

    return 0;
}

Al compilarlo con los valores asignados, produce el siguiente resultado:

V= 9.10

d=  9.04

R= 16384

R=2.0

Pero cómo no es muy fácil de apreciar, solo para este ejemplo vamos a poner "0" en lugar de espacios en blanco para que se mas fácil de apreciar (en la pantalla no para poder preservarla un poco mas.) por lo que probamos con el siguiente código:

#include <stdio.h>

float Speed = 9.1;
float Distance = 9.04;
int Revolution = 16384;
float Battery = 2.0;

char BuffSpeed[20];
char BuffDistance[20];
char BuffRevolution[20];
char BuffBattery[20];

int main()
{

    sprintf(BuffBattery , "R=%3.1f\n", Battery);
    sprintf(BuffRevolution , "R=%06d\n", Revolution);
    sprintf(BuffDistance , "d=%06.2f\n", Distance);
    sprintf(BuffSpeed, "V=%05.2f\n", Speed);

    printf(BuffSpeed);
    printf(BuffDistance);
    printf(BuffRevolution);
    printf(BuffBattery);

    return 0;
}

Al compilarlo con los valores asignados, produce el siguiente resultado:

V=09.10

d=009.04

R=016384

R=2.0

Ahora resulta mas sencillo observar que por ejemplo la velocidad siempre ocupara cinco espacios a pesar de ser menor a 10km/h y que por ejemplo la distancia ocupa seis espacios a pesar de ser menor a 100km.

Pero que pasa si tratamos de ejecutar el mismo código en arduino?

Cómo puede observarse, la mayor parte del código se compila pero no funciona. Esto se debe principalmente a que a la hora de formatear los números del tipo "float" requiere mas poder de procesamiento por lo que en arduino no se implementó (**o eso es lo que quiero creer**), para el caso del los enteros es posible usar la misma función "sprintf()".

Para poder hacer algo similar, podemos usar la funcion "dtostrf()". Esta funcion lo que hace es convertir un número "double" a su equivalente en "string", para eso la funcion recibe cuatro parametros.

• char * dtostrf (double __val, signed char __width, unsigned char __prec, char *__s)
• __val es el valor que se va a convertir
• __width es el tamaño que debe de tener la cadena.
• __prec Es la cantidad de decimales que usaran
• __s Es el sitio donde se almacenara el resultado.

dtostrf(Speed , 5 , 2 , BuffVelocity);

//YWROBOT
//Compatible with the Arduino IDE 1.0
//Library version:1.1
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
// Conexiones de la pantalla usando el convertidor a i2c
//SCL - A5
//SDA - A4
LiquidCrystal_I2C lcd(0x27,20,4);  // set the LCD address to 0x27 for a 16 chars and 2 line display

float Speed = 9.1;
float Distance = 9.04;
int Revolution = 16384;
float Battery = 2.0;

char BuffSpeed[20];
char BuffDistance[20];
char BuffRevolution[20];
char BuffBattery[20];


void setup()
{
    lcd.init();
    lcd.backlight();
}


void loop()
{
    dtostrf(Speed , 5 , 2 , BuffSpeed);
    dtostrf(Distance , 6 , 2, BuffDistance);
    sprintf(BuffRevolution , "R=%6d", Revolution);
    dtostrf(Battery , 4 , 2, BuffBattery);

    lcd.setCursor(0, 0);
    lcd.print("v=");
    lcd.setCursor(2 , 0);
    lcd.print(BuffSpeed);

    lcd.setCursor(8, 0);
    lcd.print("d=");
    lcd.setCursor(10, 0);
    lcd.print(BuffDistance);

    lcd.setCursor(0,1);
    lcd.print(BuffRevolution);

    lcd.setCursor(10,1);
    lcd.print("v=");
    lcd.print(BuffBattery);
}

 Hola de nuevo a todos, el día de hoy vamos a continuar con más aprendizaje del lenguaje de programación Pascal.

En el post anterior vimos cómo es posible crear arreglos y usar punteros, pero en el programa del triangulo de Pascal, fue cuando mucha gente prguntó cómo es que funcionaba. Hay que recordar que cuando usamos punteros, el código debe de ser bien manejado si no, pueden ocurrir cosas malas.

Para poder crear un arreglo de punteros, primero debemos de crear un par de tipos, el primero debe de ser una nuevo tipo del tipo "array of algo" donde "algo" es alguno de los tipos soportados por Pascal. Seguido debemos de crear un nuevo tipo que va a ser un puntero del tipo que acabamos de crear. Para ilustrar un poco mejor, retomemos parte del código del triangulo de Pascal.

type
    Values = array of integer;
    PValues = ^Values;

function CalculateLevel (Level : integer) : PValues;
var
    i : integer;
    Result1 : PValues;
    PResult : PValues;

begin
    
    new(Result1);
    Setlength(Result1^, Level);
    
    
    if (Level = 1) then
    begin
        Result1^[1] := 1;
    end;

    if (Level = 2) then
    begin
        Result1^[1] := 1;
        Result1^[2] := 1;
    end;
	
    if (Level > 2) then
    begin
        PResult := CalculateLevel(Level - 1);
        for i := 1 to Level do
        begin
            if (i = 1) or (i = Level) then
            begin
                Result1^[i] := 1;
            end
            else
            begin
                Result1^[i] := PResult^[i] + PResult^[i - 1];
            end;
        end;
    end;
	
    exit(Result1);
	
end;

program ArregloDePunteros;
    type
        Nombres = Array of string;
        PointToNombres = ^Nombres;
    var
        ListaDeNombres : PointToNombres;
        i : integer;
begin
    New(ListaDeNombres);
    Setlength(ListaDeNombres^ , 4);

    ListaDeNombres^[1] := 'RMFP';
    ListaDeNombres^[2] := 'RSC';
    ListaDeNombres^[3] := 'USG';
    ListaDeNombres^[4] := 'SCL';

    for i := 1 to 4 do
        writeln (ListaDeNombres^[i]);
        
end.

 Hola de nuevo a todos, el día de hoy vamos a continuar con un poco mas del lenguaje de programacion Pascal.

Hace algunos días hice un programa que sirve para calcular el triangulo de Pascal. La versión en C, Python y Pascal están disponibles para su consulta, pero a partir de ellos, se generaron dudas y si bien en el caso de Python y C siempre he dicho que en el blog no hay tutoriales para aprender a programar, en el caso de Pascal no es así. En el caso de C y Pascal se hacen uso de punteros y si bien la forma de declararlos en cada uno es diferente, la forma de uso es esencialmente la misma, por eso este post sirve para poder entender cómo es que se utilizan los punteros en Pascal, pero la idea para C es la misma (en el caso de los punteros). Para poder entender cómo se usan los tipos también es necesario saber sobre los tipos (solo en el caso de Pascal)

Tipos.

program Tipos;
type
    Colores = string;
    DiasDeLaSemana = string;
    Numeros = integer;
    
var
    MiColor : Colores;
    Hoy : DiasDeLaSemana;
    Fecha : Numeros;
    
begin

    MiColor := 'Verde';
    Hoy := 'Sabado';
    Fecha := 24;

    writeln (MiColor);
    writeln (Hoy);
    writeln (Fecha);

end.

Punteros.

En ciencias de la computación, un puntero es un objeto del lenguaje de programación, cuyo valor se refiere a (o "apunta a") otro valor almacenado en otra parte de la memoria del ordenador utilizando su dirección. Un puntero referencia a una ubicación en memoria, y a la obtención del valor almacenado en esa ubicación se la conoce como desreferenciación del puntero. A modo de analogía, un número de página en el índice de un libro podría considerarse un puntero a la página correspondiente; desreferenciar un puntero sería como ir a la página con el número de página especificada en el índice wikipedia/Punteros

En pascal, primero debemos de crear un tipo, este a su vez será un puntero de cualquiera de los admitidos por Pascal precedido por "^". Si queremos declarar un puntero hacia un valor "integer", debemos de hacer una declaración cómo la que sigue:

type
    PointToInt = ^integer;

program Pointers;
type
    PointToInt = ^integer;
var
    MiNumero : PointToInt;
begin
    new(MiNumero);
    MiNumero^ := 20;
    writeln (MiNumero^);
    Dispose(MiNumero);
end.

Arreglos.

type
ArregloDeNumeros = array[0..99] of integer;

program Arreglos;

type
ArregloDeNumeros = array[0..99] of integer;

var
MisNumeros : ArregloDeNumeros;
i : integer;

begin

    for i := 1 to 99 do
    begin 
        MisNumeros[i] := i * 2;
    end;
    
    for i := 1 to 99 do
    begin 
        writeln(MisNumeros[i]);
    end;
    
end.

program Arreglos;
uses
	sysutils;
type
	ArregloDeNumeros = array[0..99] of integer;
	ArregloDePalabras = array[0..99] of string;
var
	MisPalabras : ArregloDePalabras;
	MisNumeros : ArregloDeNumeros;
	i : integer;
begin
	for i := 0 to 99 do
	begin 
		MisNumeros[i] := i * 2;
		MisPalabras[i] := concat('EL valor de i es ', IntToStr(i));
	end;
	for i := 0 to 99 do
	begin 

	end;
end.

		writeln(MisNumeros[90]);
		writeln(MisPalabras[90]);

 Hola de nuevo el día de hoy vamos a continuar con mas del triangulo de Pascal, pero esta vez en el lenguaje de programación pascal.

Para entender un poco sobre el triangulo de pascal, recuerda que en el post "Vamos a programar #91" podemos encontrar cómo se calcula a mano y el código en Python. Ahora veamos el código en Pascal que sirve para calcular el triangulo de Pascal.

 Hola de nuevo a todos, el dia de hoy solo escribo para desearles a todos un buen año 2021, es cierto que el 2020 fue un año complicado, pero si nos sirve de consuelo a todos, el 2021 podrá ser peor (o no). Cómo es costumbre, continua visitando el blog de XWork y disfrutemos del tiempo que tenemos porque en un instante se puede acabar.

 Hola de nuevo a todos, el día de hoy vamos a ver cómo hacer un programa en C que calcule el triangulo de Pascal.

Cómo podrás recordar, hace unos día publiqué una version en Python; y tal cómo lo prometí justo antes de acabar el 2020, les traigo la versión en C. Cómo la explicación de que es el triangulo de Pascal se incluye en ese post (además de cómo hacer los cálculos a mano), simplemente pasaremos al código fuente. Al igual que el código en Python, vamos a calcular el triangulo de Pascal de manera recursiva y si surgen dudas las resolveremos en los próximos post

El código en C que sirve para calcular el triangulo de Pascal es el siguiente ():

// Prueba del triangulo de pascal en C

#include <stdio.h>
#include <stdlib.h>

int *CalculateLevel(int Level)
{
    int *Result;
    Result  = (int *)malloc(Level * sizeof(int));
        
    if (Level == 0)
         *Result = 1;
    if (Level == 1)
    {
        *Result = 1;
        *(Result + 1) = 1;
    }
    if (Level > 1)
    {
        int *ResultP = CalculateLevel(Level - 1);
        for (int i = 0; i < Level; i++)
        {
            if (i == 0 || i == Level - 1)
                *(Result + i) = 1;
            else
                *(Result + i) = *(ResultP + i) + *(ResultP + i - 1);
        }
    }
    return(Result);
    
}

void DrawPascalTriangle(int Number)
{

    if (Number > 20)
    {
        printf("Solo se admiten 20 niveles");
    }
    else
    {
        for (int i = 0; i < (Number + 1); i++)
        {
            int *Result = CalculateLevel(i);
            for (int j = 0; j < i; j++)
            {
                printf( " %5d ", *(Result + j));
            }
        printf("\n");
        }

    }
}


int main()
{
    int Levels;
    printf("Numero de niveles\n");
    scanf("%d", &Levels);
    DrawPascalTriangle(Levels);

    return 0;
}

 Hola de nuevo a todos, el día de hoy vamos a ver cómo hacer el triangulo de pascal usando Python.

Hace unos días mientras leía los comentarios, alguien sugirió que hiciera un programa que calculara el triangulo de pascal y ya que ando un poco corto de ideas, decidí hacerlo. Pero antes de continuar, veamos que es el triangulo de pascal.

En las matemáticas, el triángulo de Pascal es una representación de los coeficientes binomiales ordenados en forma de triángulo. Es llamado así en honor al filósofo y matemático francés Blaise Pascal, quien introdujo esta notación en 1654, en su Traité du triangle arithmétique.1​ Si bien las propiedades y aplicaciones del triángulo fueron conocidas con anterioridad al tratado de Pascal por matemáticos indios, chinos, persas, alemanes e italianos, fue Pascal quien desarrolló muchas de sus aplicaciones y el primero en organizar la información de manera conjunta.2​

El triángulo de Pascal se puede generalizar a dimensiones mayores. La versión de tres dimensiones se llama pirámide de Pascal o tetraedro de Pascal, mientras que las versiones más generales son llamadas simplex de Pascal.

Wikipedia/Triangulo De Pascal

 La composición del triangulo de pascal es realmente simple, en la cima del triangulo, siempre ubicaremos un uno, de hecho en todas las orillas pondremos un uno de modo que en cada nivel haya tantos número cómo el nivel en el que estamos. Para el nivel dos, ya que solo hay extremos en ambos se pondrá un uno.

Para calcular los números del tercer nivel, imaginemos que tenemos tres lugares, los extremos deben de llevar el número uno, por lo que solo nos hace falta determinar el que esta en el lugar dos. Para hacerlo de manera "sencilla" debemos de revisar el nivel anterior y debemos de sumar el numero que esta en la misma posición que el numero que queremos saber (DEL NIVEL ANTERIOR), y sumarlo con el que inmediatamente antes. Para darnos una idea, miremos la siguiente imagen.

Si revisamos bien, nos ubicamos en el nivel tres, pero el numero que queremos saber es el que esta en el segundo lugar del tercer nivel (marcado con una X), entonces tenemos que tomar el numero del nivel anterior que esta en las misma posición que nuestro numero, en la imagen podemos apreciar que el número que esta en la segunda posición del nivel dos es uno y el numero que esta antes en el nivel dos, también es uno, por lo que tendríamos que el segundo numero del tercer nivel es igual a uno mas uno, por lo tanto su valor es dos.

Ahora a manera de ejemplo calculemos el valor de los números en el nivel 4, para eso imaginemos que tenemos algo cómo la imagen que sigue.

Para calcular el numero Y, simplemente hacemos lo mismo. Tomamos el tercer y segundo número del nivel tres y simplemente lo sumamos obteniendo otro tres.

Así podemos calcular cualquier nivel.

Entonces en python podemos crear código cómo el que sigue:

# Prueba del triangulo de pascal en python
def CalculateLevel(Level):
    Result = {}
    if Level == 1:
        Result[0] = 1
    if Level == 2:
        Result[0] = 1
        Result[1] = 1
    if Level > 2:
        ResultP = CalculateLevel(Level - 1)
        for i in range(Level):
            if (i == 0) or (i == Level - 1):
                Result[i] = 1
            else:
                Result[i] = ResultP[i - 1] + ResultP[i]
    return Result
 
def DrawPascalTriangle(Number):
    if Number > 20:
        print("Solo se admiten 20 Niveles")
    else:
        for i in range(Number + 1):
            Result = CalculateLevel(i)
            for j in range(len(Result)):
                print(Result[j], end = '  ')
            print()
    


if __name__ == "__main__":
    import sys
    DrawPascalTriangle(int(sys.argv[1]));

pascaltri.py 20

 Hola de nuevo a toos, el dia de hoy vamos a ver un poco de Python. En días anteriores, mientras revisaba algunos comentarios en twitter, aalgunas personas me preguntaron sobre el estado del blog, pese al que el estado actual ha empeorado un poco debido a cierto bicho, el hecho fue que un par de "accidentes" me impidieron crear nuevos post. Pero dejando eso de lado, mucha gente pidio que si les podia ayudar con python (si hacemos memoria, casi no hay programas hechos en éste lenguaje), y la razon principal es debido a que simplemente lo olvide (conste que ya lo habia mencionado en algun post). Para probar que aun estoy al pendiente, decidi hacer un par de programas con (segun google) las busquedas mas gfrecuentes relacionadas a python que conducian a mi blog.

Los números de Fibonacci.

def CalcFibonacci(Number):
    v1 = 0
    v2 = 1
    v3 = 0
    
    while v1 < Number:
        print(v1)
        v3 = v1 + v2
        v1 = v2
        v2 = v3


if __name__ == "__main__":
    import sys
    CalcFibonacci(int(sys.argv[1]))

Fibonacci.py 200

La funcion de Ackerman.

def AckermanFunction(Number1, Number2):
    if Number1 == 0:
        return Number2 + 1
    else:
        if Number2 == 0:
            return (AckermanFunction(Number1 - 1, 1))
        return (AckermanFunction(Number1 - 1, AckermanFunction(Number1, Number2 - 1)))

if __name__ == "__main__":
    import sys
    try:
        for i in range(4):
            for j in range(5):
                print(AckermanFunction(i, j),end='  ')
            print()
    except RecursionError:
        print("Error: Se alcanzo el maximo de recursion permitido")