Mostrar los tags: li

Mostrando del 11 al 20 de 554 coincidencias
Se ha buscado por el tag: li
Imágen de perfil

Cx_Contabilidad Financiera


Visual Basic

estrellaestrellaestrellaestrellaestrella(9)
Actualizado el 14 de Enero del 2025 por Rafael (28 códigos) (Publicado el 21 de Diciembre del 2022)
60.011 visualizaciones desde el 21 de Diciembre del 2022
Cx es un programa para Windows.
Sirve para gestionar la contabilidad.
Produce: libro diario, auxiliar,
balanzas, recapitulación, estados financieros,
balance general, estado de pérdidas y ganancias,
estado de resultados y estados de cuentas.
Servosistema que administra
la oficina sin papeles.
Multiusuario cliente/servidor, red inalámbrica.
Código abierto. Trabajo a distancia.
Adjunto Cx Guía del rey de la creación

Sin-titulo
Imágen de perfil

Base de datos sqlite.


Python

Publicado el 16 de Diciembre del 2024 por Hilario (145 códigos)
1.766 visualizaciones desde el 16 de Diciembre del 2024
Captura-de-pantalla-de-2024-12-15-21-08-21
Captura-de-pantalla-de-2024-12-15-21-10-06

************************************************////*******************************************



Aula_28_Diciembre_15_sql.py
**********************************


Programa realizado bajo paltaforma Linux, concretamente con Ubuntu 20.04.6 LTS.
Editado con Sublime text

#Ejecución.
#Bajo consola linux.
python3 Aula_28_Diciembre_15_sql.py
Alumnos, para entender mejor este ejercicio, inicialmente vamos a instalar el programa para Linux: DB Browser for SQLite
------------------------------------------//--------------------------------
Utilizaremos este comando por consola de linux, en mi caso utilizo Ubuntu.
sudo apt install sqlitebrowser

***************************************************************************************************
Vamos a realizar un ejercicio en Python, con el fin de relacionar un programa orientado a base de datos, para ir cargandolos secuencialmente en nuestra base datos y poder ver bajo genome, con el programa DB Browser for SQLite, los resultados.
Creo que es lo más sencillo que podemos hacer, queridos alumnos, para aprender sobre este importante tema, las bases SQL.


Bien, vamos a ver un poco este ejercicio.

Explicación General del Ejercicio: Aula_28_Diciembre_15_sql.py
Clase del 18 de Diciembre - Aula 28 (Mañana)

Este ejercicio tiene como objetivo enseñar a los alumnos cómo crear, gestionar y manipular una base de datos utilizando SQLite en Python. Se presenta una agenda de contactos como ejemplo práctico, con funcionalidades para agregar, buscar, eliminar y listar contactos. El archivo generado se llama Aula_28_Agenda.db y será almacenado localmente.

Conceptos Clave:
SQLite:
Es un sistema de gestión de bases de datos ligero y sin servidor. No requiere configuración previa, lo que lo hace ideal para proyectos pequeños o educativos.

Base de datos:
Un lugar donde almacenamos datos organizados en tablas. En este caso, tenemos una tabla llamada contactos que almacena:

id: Identificador único (autoincremental).
nombre: Nombre del contacto.
telefono: Número de teléfono.
ciudad: Ciudad del contacto.

Python y SQL:
Python se conecta con SQLite usando la biblioteca sqlite3. Los comandos SQL (CREATE, INSERT, SELECT, DELETE) nos permiten manipular los datos.

Estructura del Programa:

1. Inicialización de la Base de Datos:

La función inicializar_db() crea el archivo Aula_28_Agenda.db si no existe.
Dentro de este archivo, se define la tabla contactos con sus columnas (id, nombre, telefono, ciudad).
Se utiliza SQL para asegurar que la tabla se cree solo si no existe previamente.

Código relevante:

CREATE TABLE IF NOT EXISTS contactos (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nombre TEXT NOT NULL,
telefono TEXT NOT NULL,
ciudad TEXT NOT NULL
)

2. Agregar Contactos

La función agregar_contacto(nombre, telefono, ciudad) permite al usuario añadir contactos a la base de datos.
Se utiliza una consulta SQL INSERT para insertar los datos proporcionados por el usuario.

INSERT INTO contactos (nombre, telefono, ciudad) VALUES (?, ?, ?)

3. Buscar Contactos

La función buscar_contacto(nombre) permite buscar contactos en la base de datos que coincidan parcialmente con un nombre.
Utiliza SELECT con una condición LIKE para encontrar coincidencias.
SELECT nombre, telefono, ciudad FROM contactos WHERE nombre LIKE ?

4. Eliminar Contactos

La función eliminar_contacto(nombre) elimina todos los contactos cuyo nombre coincida con el criterio de búsqueda.
Utiliza DELETE para borrar los registros encontrados.

DELETE FROM contactos WHERE nombre LIKE ?

5. Mostrar Todos los Contactos

La función mostrar_agenda() lista todos los contactos almacenados en la base de datos.
Utiliza SELECT para recuperar toda la información de la tabla contactos.


SELECT nombre, telefono, ciudad FROM contactos
Interacción con el Usuario
El programa incluye un menú interactivo que guía al usuario por las diferentes funcionalidades de la agenda.
Este menú permite:

Opción 1: Agregar un contacto.
Opción 2: Buscar un contacto.
Opción 3: Eliminar un contacto.
Opción 4: Mostrar todos los contactos.
Opción 5: Salir del programa.

El menú se ejecuta dentro de un bucle while hasta que el usuario elige salir.

Ejemplo Práctico
Al ejecutar el programa, se crea el archivo Aula_28_Agenda.db.
Desde el menú:
Seleccionas 1. Agregar contacto, introduces Juan, 123456789 y Madrid.
Seleccionas 2. Buscar contacto, introduces Juan y ves los detalles de ese contacto.
Seleccionas 3. Eliminar contacto, introduces Juan y confirmas que se ha eliminado.
Seleccionas 4. Mostrar todos los contactos, y verificas que no hay contactos.

Objetivos de Aprendizaje
Comprender cómo funcionan las bases de datos relacionales.
Conectar y manipular bases de datos SQLite desde Python.
Implementar operaciones básicas de bases de datos:
Crear tablas (CREATE).
Insertar datos (INSERT).
Leer datos (SELECT).
Eliminar datos (DELETE).

Desarrollar un programa estructurado y modular.
-----------------------------------------------------------------------------------------------------
Conclusión
Este ejercicio combina teoría y práctica para ayudar a los alumnos del Aula 28 a entender el manejo de bases de datos desde Python. Los conceptos aprendidos pueden ser aplicados en proyectos más complejos en el futuro.
Imágen de perfil

Elíptica_Criptografía


Python

Publicado el 27 de Noviembre del 2024 por Hilario (145 códigos)
1.093 visualizaciones desde el 27 de Noviembre del 2024
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Figure_1

---------------------------------------------------------------------------------------------------------------------------

Captura-de-pantalla-de-2024-11-27-12-07-57

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


Aula_28_Nov_Eliptica_Criptografia.py
+++++++++++++++++++++++++++++




Dentro de todas las partes, digamos, técnologicas, que hemos ido estudiando y procesando. Comenzamos un tema nuevo,
para el que seguiremos utilizando el lengua Python, y un sistema operativo basado en linux.
Nos adentramos en el mundo de la criptografía y de las claves, en principio, en los sistemas más utilizados
por el secure shel SSH, en principio con un ejemplo sencillo, que intentaré explicar lo mejor posible.
Como siempre, en nuestras sucesivas clases de técnología iremos aclarando las dudas que surjan, lo que supondrá, como siempre
ocurre en nuestras clases, profundizar mucho más sobre el tema. Os pido, que dentro de lo posible, intenteis razonar el código.
Luego ya aclararemos todo lo que surja, pero es más fácil su comprensión si llevamos, digamos, trillado, un poco de lo que se trata.

EMPECEMOS:
++++++++++++++

-¿Qué es una curva elíptica?
Una curva elíptica es una curva matemática que tiene la forma general:
y2=x3+ax+b (Ya sabeis, y elevado a 2, igual a x elevado a 3, más a por x, más b)
Esta curva tiene propiedades interesantes que se aprovechan en criptografía para generar claves. En criptografía de curvas elípticas (ECC, por sus siglas en inglés), usamos puntos sobre esta curva para construir un sistema de claves.


¿Cómo se construyen las claves con una curva elíptica?
1. Selección de la curva elíptica:
◦ Primero, se elige una curva elíptica específica. La ecuación y2=x3+ax+b tiene parámetros como a, b, y un número primo p que define el campo finito (es decir, trabajamos con números que están "limitados" por un número p).
◦ Un ejemplo común de curva elíptica es la curva secp256k1, que se usa en Bitcoin.

2. Punto generador (G):
◦ Sobre la curva elíptica, hay un punto generador G que es un punto específico de la curva, que se conoce de antemano. Este punto sirve para generar las claves.

3. Clave privada:
◦ La clave privada es un número aleatorio que se elige de manera segura. Es como una "semilla" que vamos a usar para generar la clave pública.
◦ Este número privado es secreto, y nunca se debe compartir.

4. Clave pública:
◦ La clave pública se genera multiplicando el punto generador G por el número privado (clave privada). Esto se hace mediante una operación llamada multiplicación escalar.
◦ Matemáticamente, si tienes una clave privada k, la clave pública P es: P=k⋅G
◦ Aquí, P es un nuevo punto sobre la curva que depende de k y G. Es casi imposible calcular k solo a partir de P, lo que hace la curva elíptica segura para su uso en criptografía.

5. Uso en criptografía:
◦ En criptografía de clave pública, puedes usar la clave pública para verificar la autenticidad de un mensaje o para cifrar datos.
◦ Solo la persona que tiene la clave privada puede descifrar los datos o firmar mensajes, porque se necesita la clave privada para generar la firma o descifrar.

Ejemplo práctico en criptografía
Imagina que quieres enviar un mensaje seguro a alguien:
1. La otra persona te envía su clave pública.
2. Tú usas esa clave pública para cifrar el mensaje.
3. La otra persona usa su clave privada para descifrarlo.
Y cuando firmes un mensaje:
1. Usas tu clave privada para firmar el mensaje (de forma que solo tú puedas hacerlo).
2. Cualquier persona que tenga tu clave pública puede verificar que la firma es auténtica y que no ha sido modificada.

¿Por qué es segura?
La seguridad de este sistema se basa en que, aunque la multiplicación escalar de un número por un punto en la curva es fácil de hacer, el proceso inverso (saber la clave privada a partir de la clave pública) es extremadamente difícil. Este problema se llama el problema del logaritmo discreto, y es la base de la seguridad de las curvas elípticas.

En fin, alumnos, resumiendo:
1. Clave privada: Número secreto que eliges.
2. Clave pública: Punto en la curva generado a partir de la clave privada.
3. Suma de puntos: Usada para multiplicar el punto generador G para obtener la clave pública.
4. Seguridad: Es muy difícil calcular la clave privada a partir de la clave pública.


Este enfoque se usa en criptografía moderna para asegurar comunicaciones y transacciones, como en Bitcoin o en protocolos TLS/SSL para la navegación segura por Internet.
----------------------------------------------------------------------------------------------------------------------------------

Bien, después de esta pequeña introducción, que ampliaremos en clase, la próxima semana y sucesivas, vamos con algo más práctico:

1. Representación gráfica de la curva elíptica.
---------------------------------------------------------------
El programa comienza generando una gráfica de la curva elíptica definida por y2=x3+8x+12 sobre los números reales:
• Cálculo de y2:
La ecuación se evalúa para valores de x en un rango definido [−10,10] para obtener los valores de y2.
• Raíces cuadradas positivas y negativas:
La raíz cuadrada de y2 se toma tanto positiva como negativa (y=±y2​) para trazar ambas ramas de la curva.
• Visualización:
Usa matplotlib para graficar las ramas positiva y negativa en colores distintos. También incluye líneas de referencia para los ejes x e y, junto con una cuadrícula para mejorar la legibilidad.
Propósito:
Este gráfico permite entender visualmente la forma de una curva elíptica sobre los números reales antes de trabajar con el caso modular (campo finito).

2. Implementación de una curva elíptica modular (campo finito pequeño)
-------------------------------------------------------------------------------------------------------
En esta sección, se define una clase EllipticCurve para manejar operaciones básicas en una curva elíptica sobre un campo finito

Fp​:
• Parámetros de la curva:
La curva está definida por y2=x3+ax+bmodp, donde:
◦ a=8, b=12, y p=97 (un número primo que define el campo).
• Validación de singularidades:
Verifica que la curva no sea singular usando la condición 4a3+27b2=0modp.

• Operaciones básicas:
◦ Pertenencia a la curva: Verifica si un punto (x,y) está en la curva.
◦ Suma de puntos: Implementa la adición de puntos, considerando casos como:
▪ P+O=P (punto identidad).
▪ Suma de puntos distintos.
▪ Duplicación de un punto (derivada de la tangente).
◦ Multiplicación escalar: Repite la suma k⋅P usando el algoritmo de duplicación y adición.

• Generación de claves:
◦ Se generan todos los puntos válidos en la curva para el campo F97​.
◦ Selecciona un punto generador G (el primero de la lista).
◦ La clave privada es un entero aleatorio entre 1 y p−1.
◦ La clave pública es el resultado de k⋅G, donde k es la clave privada.

Resultados:
Imprime:
• La ecuación de la curva modular.
• El punto generador G.
• Las claves privada y pública generadas.

3. Criptografía realista con secp256k1
Esta sección introduce una curva elíptica de uso práctico en criptografía, secp256k1, utilizada por Bitcoin:
• Definición:
La curva está definida por y2=x3+7modp, donde:
◦ p es un número primo grande (2256−232−977).
◦ G es un punto generador predeterminado en la curva.
◦ n es el orden del punto generador.
• Operaciones similares:
Implementa las mismas operaciones (pertenencia, suma de puntos, multiplicación escalar) adaptadas a los parámetros de secp256k1.
• Generación de claves:
◦ La clave privada es un número aleatorio de hasta 256 bits (1≤k<n).
◦ La clave pública es k⋅G, donde G y n aseguran un espacio de claves inmenso y seguridad criptográfica.
Resultados:
Muestra:
• La ecuación de secp256k1.
• El punto generador G.
• Las claves privada y pública.


Como véis, queridos alumnos, el propósito formativo del programa es:
++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++
1. Introducción visual a las curvas elípticas:
La gráfica inicial ayuda a entender cómo luce una curva elíptica y su simetría sobre los números reales.
2. Conceptos básicos de curvas elípticas en campos finitos:
◦ Explica cómo las curvas se definen y operan en un espacio modular, con un ejemplo simple (p=97).
◦ Introduce operaciones críticas como suma de puntos y multiplicación escalar.
3. Aplicación práctica en criptografía:
◦ Usa una curva criptográfica estándar (secp256k1) para mostrar cómo generar claves privadas y públicas.
◦ Destaca las diferencias entre un ejemplo educativo y un caso práctico con parámetros reales.

Bien, y como posibles mejoras, vamos a implementar lo siguiente:
---------------------------------------------------------------
• Implementar firmas digitales (ECDSA) como extensión práctica.
• Mostrar cómo la clave pública se convierte en un formato útil (como direcciones en Bitcoin).
• Incluir explicaciones más detalladas sobre seguridad y resistencia frente a ataques.


Comoos lo expuesto, tengo por sentado que os resultará un tanto farragoso, deseo que, como ya dije, comencéis su estudio-
Iremos puliendo dudas, y asentando conceptos los próximos días.



///////////////////////////////////////////////////////////////////////////
Como casi todos los ejercicios, este fue realizado, bajo una plataforma Linux,
en concreto con Ubuntu 20.04.6 LTS.
Fue editado con Sublime Text.
Se utilizó, Python3.
Y como smpre indico, se deberán de tener cargadas en el sistema, todas las librerias
que el código pide importar para su ejecucucíon.

Comando de ejecucuón bajo consola linux:

python3 Aula_28_Nov_Eliptica_Criptografia.py
Imágen de perfil

Espectrometría


Python

Publicado el 30 de Agosto del 2024 por Hilario (145 códigos)
426 visualizaciones desde el 30 de Agosto del 2024
Figure_1



Propongo el sencillo ejercicio en phyton : Aula_28_Ag.24_Espectro_Masas.py. Este ejercicio elabora una pequeña simulación planteando una espectrometría de una molécula de agua. Explicaremos, previamente un poco, en que consiste las espectrometría de masas.
-----------------------------------------------------------------------------------------------------------------------------------

La espectrometría de masas (MS, por sus siglas en inglés) es una técnica analítica utilizada para medir la relación masa/carga (m/z) de los iones presentes en una muestra. En el contexto de una molécula, como la del agua (H₂O), la espectrometría de masas permite identificar y cuantificar los fragmentos iónicos que resultan de la ionización de la molécula, lo que a su vez proporciona información sobre su estructura molecular y su composición.

Principios Básicos de la Espectrometría de Masas

Ionización:
-------------
La muestra, que puede ser un sólido, líquido o gas, se introduce en el espectrómetro de masas, donde se somete a un proceso de ionización. Este proceso convierte las moléculas en iones cargados (generalmente positivos) al agregar o quitar electrones.
Existen varios métodos de ionización, como la ionización por impacto electrónico (EI), electrospray (ESI), y ionización química (CI), entre otros.

Aceleración:
---------------
Los iones generados se aceleran mediante un campo eléctrico, de modo que todos los iones con la misma carga tengan la misma energía cinética.

Deflexión:
------------
Los iones acelerados pasan a través de un campo magnético o eléctrico que los desvía en función de su relación masa/carga (m/z). Los iones más ligeros y con una mayor carga se desvían más que los iones más pesados.

Detección:
-------------
Los iones desviados impactan en un detector que mide la intensidad de la señal, la cual está relacionada con la cantidad de iones presentes. La intensidad se registra para cada valor de m/z, generando así un espectro de masas.
Interpretación del Espectro de Masas

El resultado de la espectrometría de masas es un gráfico denominado espectro de masas, donde:

Eje X: Representa la relación masa/carga (m/z) de los iones.
Eje Y: Representa la intensidad o abundancia relativa de los iones detectados.
Cada pico en el espectro corresponde a un ion con una relación m/z específica. La altura del pico indica la cantidad relativa de ese ion en la muestra.

Aplicación a la Molécula de Agua (H₂O)
-----------------------------------------------------------
Para una molécula simple como el agua, la espectrometría de masas puede revelar varios iones, dependiendo del método de ionización:
----------------------------------------------------------------------------------------------------------------------------------
H₂O⁺ (m/z = 18): Ion molecular de agua sin fragmentar.
OH⁺ (m/z = 17): Fragmento ionizado que resulta de la pérdida de un átomo de hidrógeno.
O⁺ (m/z = 16): Ion de oxígeno, que podría resultar de la fragmentación de la molécula.
H⁺ (m/z = 1): Ion de hidrógeno.
En un espectro de masas de agua, podrías ver picos en estos valores de m/z, reflejando la presencia de estos fragmentos iónicos.

Ejemplo de Uso en Química y Biología.
---------------------------------------------------
Identificación de Compuestos: Al comparar el espectro de masas de una muestra con espectros de referencia, los químicos pueden identificar compuestos desconocidos.
Determinación de Estructuras Moleculares: La forma en que una molécula se fragmenta puede proporcionar pistas sobre su estructura química.
Cuantificación de Análisis: La espectrometría de masas también se usa para cuantificar la cantidad de un compuesto en una muestra, especialmente en el análisis de mezclas complejas.
Conclusión
La espectrometría de masas es una herramienta poderosa para estudiar las propiedades de las moléculas al identificar sus fragmentos iónicos y medir sus relaciones masa/carga. En la práctica, esta técnica tiene aplicaciones en química, biología, farmacología y muchas otras disciplinas científicas.

******************************************************************************************



Simulación del Espectro de Masas
--------------------------------------------------------
El espectro de masas para una molécula de agua podría incluir los siguientes iones:

H₂O → m/z = 18 (ion molecular)
OH → m/z = 17
O → m/z = 16
H → m/z = 1



Explicación del Código:
Fragmentos y sus m/z: Definimos las relaciones m/z para diferentes fragmentos posibles de la molécula de agua (H2O+, OH+, O+, H+).

Intensidades Relativas: Asignamos intensidades relativas a estos picos basadas en la probabilidad de fragmentación.

Espectro Simulado: Generamos un espectro de masas añadiendo picos gaussianos centrados en los valores de m/z definidos.

Visualización: El gráfico muestra la relación masa/carga (m/z) en las abscisas y la intensidad relativa en las ordenadas.

Resultado:
Al ejecutar este código, obtendrás un gráfico que simula un espectro de masas para una molécula de agua, donde se visualizan los diferentes iones generados por la fragmentación de la molécula. Este es un modelo simplificado, pero proporciona una base para entender cómo se podrían visualizar los datos obtenidos en un espectrómetro de masas.
-------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------
El ejercicio fue realizado en una plataforma linux. Concretamente en: Ubuntu 20.04.6 LTS.
Fue editado con Sublime text.
Ejecutado bajo consola Linux con el siguiente comando:
python3 Aula_28_Ag.24_Espectro_Masas.py

Se deberán tener cargados los siguientes módulos:
import numpy as np
import matplotlib.pyplot as plt

Ejecutado con python en versión:3
-------------------------------------------------------
Imágen de perfil

Repaso graficos con matplotlib


Python

Publicado el 29 de Mayo del 2024 por Hilario (145 códigos)
561 visualizaciones desde el 29 de Mayo del 2024
Figure_1


**********************************************************************************************************************

Repaso-matplotlib-Aula-38-uranio-235.py
------------------------------------------------------
Con la idea de repasar la librería matplotlib, propongo este sencillo ejercicio de la representación aleatoria de un átomo de Uranio-235.
El ejercicio es de ejecución sencilla, y puede el alunno jugar con sus datos de entrada.
La librería matplotlib, es de uso habitual en todos los programas graficados, incluidos
los de inteligencia artificial.
----------------------------------------------------------------------------------------
Vamos a dar una pequeña descripción de Física cuántica, con el fin de entender este desarrollo.
********************************************************************************************
En la física cuántica, la idea de electrones orbitando alrededor del núcleo en trayectorias definidas, como planetas alrededor del sol, es incorrecta y ha sido reemplazada por un modelo más complejo y preciso.

En el modelo cuántico, los electrones no tienen órbitas definidas. En cambio, se describen mediante funciones de onda, que son soluciones a la ecuación de Schrödinger. Estas funciones de onda no nos dicen la trayectoria exacta de un electrón, sino la probabilidad de encontrar un electrón en una determinada región del espacio alrededor del núcleo. Esta región donde es más probable encontrar al electrón se llama "orbital".

Los orbitales tienen diferentes formas y tamaños, y cada uno corresponde a un nivel de energía específico. Los orbitales son esféricos, los p tienen forma de mancuerna, los d y f son más complejos. La densidad de probabilidad, que es la interpretación de la función de onda, nos da una "nube electrónica" donde la densidad de esta nube es mayor en las regiones donde es más probable encontrar al electrón.

En resumen:

Modelo Cuántico: En lugar de órbitas definidas, los electrones existen en "nubes de probabilidad" llamadas orbitales.
Funciones de Onda: Describen la probabilidad de encontrar un electrón en una determinada región del espacio.
Orbitales: Las diferentes formas (s, p, d, f) corresponden a diferentes distribuciones de probabilidad y niveles de energía.
Así que, efectivamente, los electrones están en un estado de movimiento continuo y no podemos determinar su posición exacta, sino solo la probabilidad de encontrarlo en un lugar determinado en un momento dado.


********************************************************************

Podemos crear una visualización simple utilizando la biblioteca matplotlib en Python para representar el núcleo atómico y una nube de electrones en movimiento aleatorio. A continuación, os presento el código Repaso-matplotlib-Aula-38-uranio-235.py
para crear esta simulación:

Este código hace lo siguiente:

Configuración inicial: Define el número de electrones y el límite del espacio donde se moverán.
Posiciones iniciales: Genera posiciones iniciales aleatorias para los electrones dentro de un cubo centrado en el núcleo.
Gráfico: Configura el gráfico 3D utilizando matplotlib.
Núcleo y electrones: Dibuja el núcleo en el centro y los electrones en sus posiciones iniciales.
Función de actualización: Mueve los electrones aleatoriamente en cada fotograma, asegurándose de que permanezcan dentro de los límites definidos.
Animación: Utiliza FuncAnimation de matplotlib para animar el movimiento de los electrones.
Este es un modelo simplificado y no representa fielmente la mecánica cuántica, pero da una buena visualización de un núcleo y una nube de electrones moviéndose aleatoriamente alrededor
de él.

*****************************************************************************************

Umbral de órbita extrema: Se define una variable umbral_extremo que establece el límite a partir del cual consideramos que un electrón está en la órbita extrema.
Función de actualización:
Se calcula la distancia de cada electrón al núcleo usando np.linalg.norm.
Se separan los electrones en dos grupos: normales y extremos, según la distancia calculada.
Se limpian y vuelven a dibujar todos los elementos del gráfico en cada fotograma.
Se plotean los electrones normales en azul y los extremos en rosa.
Esto resaltará los electrones que están a punto de salirse de la órbita con un color rosa en la animación.

********************************************************************************************
Realizado en Linux, ubuntu.
Ejecución.
python3 Repaso-matplotlib-Aula-38-uranio-235.py
Imágen de perfil

Suavizado de imagen en archivos de vídeo por 'Filtrado bilateral', (aplicación en línea de comandos)


Python

estrellaestrellaestrellaestrellaestrella(2)
Actualizado el 23 de Mayo del 2024 por Antonio (77 códigos) (Publicado el 20 de Marzo del 2023)
8.348 visualizaciones desde el 20 de Marzo del 2023
Programa para realizar filtrado de imagen en archivos de vídeo (preferiblemente de corta duración) utilizando el algoritmo de 'filtrado bilateral' pudiendo especificar los valores sigma de espacio y color y el diámetro del vecindario para cada pixel. Los vídeos filtrados se generan, por defecto, conservando su sonido, aunque se pueden generar sin este introduciendo el argumento '-ae'/'--exclude_audio'.

ARGUMENTOS:
-src/--source: Nombre del vídeo original (OBLIGATORIO)
-dest/--destination: Nombre del video a generar ('NewFilteredVid.mp4' por defecto)
-sgc/--sigma_color: Valor sigma para espacio de color (75 por defecto)
-sgs/--sigma_space: Valor sigma espacial (75 por defecto)
-pd/--pixel_diameter: Diámetro de la vecindad de píxeles (9 por defecto)
-ae/--exclude_audio: Excluir audio y generar video sin sonido (OPCIONAL)

PARA CUALQUIER DUDA U OBSERVACIÓN UTILIZEN LA SECCIÓN DE COMENTARIOS
bvf
bvf2
bvf3
bvf4
Imágen de perfil

Generador de valores hash para contraseñas.


Python

Actualizado el 5 de Mayo del 2024 por Antonio (77 códigos) (Publicado el 20 de Noviembre del 2022)
2.516 visualizaciones desde el 20 de Noviembre del 2022
El siguiente programa genera valores hash para una contraseña, utilizando distintos algoritmos. También permite la copia de las salidas generadas.
ph
Imágen de perfil

Visor de gráficos financieros.


Python

estrellaestrellaestrellaestrellaestrella(2)
Actualizado el 1 de Abril del 2024 por Antonio (77 códigos) (Publicado el 7 de Julio del 2021)
11.147 visualizaciones desde el 7 de Julio del 2021
El programa muestra información relativa al precio máximo, mínimo, de apertura y cierre de un activo financiero (estos se irán almacenando en el archivo "symbols" que se generará al ejecutar el programa por primera vez) y para un periodo de tiempo. También muestra los gráficos relativos a las medias móviles exponenciales de 50 y 200 sesiones.
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.
gf
Imágen de perfil

Visualización de la imagen normalizada.


Python

Publicado el 22 de Enero del 2024 por Hilario (145 códigos)
537 visualizaciones desde el 22 de Enero del 2024
Sencillo_Concep_Pixel_Aula_28.py
**********************

Figure_1
Figure_12

********************************************************************************************************************

Con este sencillo y diminuto ejercicio, tratamos de explicar algunas dudas conceptuales sobre el tratamiento y comprensión
del funcionamiento de los pixeles. Aula 28.
-----------------------------------------------------------------------------------------------------------------------

Definición de los valores del píxel:
------------------------------------------------
Se especifican los valores de los canales rojo, verde y azul del píxel. En este caso, son [88, 15, 108].

Visualización de la imagen sin normalización:
---------------------------------------------------------------
Se crea una imagen de 1x1 píxeles con los valores de los canales y se muestra directamente. La escala de colores refleja los valores originales sin ajustes.

Normalización de los valores de los canales:
--------------------------------------------------------------
Se normalizan los valores de los canales dividiéndolos por 255.0. Este paso es común en procesamiento de imágenes para asegurarse de que los valores estén en el rango [0, 1].

Visualización de la imagen normalizada:
--------------------------------------------------------
Se crea una nueva imagen con los valores normalizados y se muestra. La escala de colores ahora refleja los valores ajustados al rango [0, 1].

Impresión de la matriz normalizada:
--------------------------------------------------
La matriz normalizada se imprime en la consola. Esto muestra cómo los valores de los canales se han ajustado a la escala [0, 1].

En resumen, el código realiza dos visualizaciones de un píxel: una con los valores de los canales originales y otra después de normalizar esos valores para asegurarse de que estén en un rango comprensible para la visualización de colores.

Salida por consola de los pixels normalizados.


[[0.34509804 0.05882353 0.42352941]]



***********************************************************************************************
Realizado en Plataforma Linux. Ubuntu 20.04.6 LTS
Editado con Sublime text.
Ejecución:python3 Sencillo_Concep_Pixel_Aula_28.py
************************************************************************************************
Imágen de perfil

Capas de Agrupación (Pooling).


Python

Publicado el 14 de Diciembre del 2023 por Hilario (145 códigos)
560 visualizaciones desde el 14 de Diciembre del 2023
Aula_68_EP_IA.py
************************************************************************
Proponemos este nuevo ejercicio prosiguiendo con el aprendizaje sobre convoluciones y max pooling, en el tratamiento de una imagen en OpenCV.
Esquemáticamente este ejercicio implementas varios conceptos importantes:

*Carga de la imagen con cv2
*Conversión a escala de grises
*Definición de un kernel de convolución 3x3
*Aplicación de múltiples convoluciones en loops (8 iteraciones)
*Reducción del tamaño de la imagen con max pooling después de cada convolución
*Impresión de los valores de píxeles resultantes
*Visualización de la imagen original vs la imagen procesada
*Adicionalmente, la función que imprime los valores de pixeles con sus índices es muy útil para inspeccionar los cambios paso a paso después de cada iteración.

La salida debe mostrar efectivamente cómo se suaviza y resalta el contraste en la imagen resultado, después de aplicar las capas de convolución y pooling.

En resumen, el código trata de ser sencillo y didáctico, para mostrar el efecto que tiene aplicar una CNN sobre imágenes. En este caso con 8 convoluciones.

El ejercicio permite modificar parametros para observar nuevos valores y matices en la imagen.

El siguiente paso sería, en otro ejercicio, la aplanación de los valores obtenidos para pasar y entregarlos a una red neuronal con capas Completamente Conectadas (Densas):

Esto quiere decir que después de las capas de convolución y agrupación, la red puede incluir capas completamente conectadas. En estas capas, todas las neuronas están conectadas entre sí, para optener el resultado final que pretendemos en el modelo que vayamos a crear.

Eso tendrá cabida, como dije, en un próximo ejercicio.

*****************************************************************************
Figure_1