Mostrar los tags: tp

Mostrando del 1 al 10 de 54 coincidencias
<<>>
Se ha buscado por el tag: tp
Imágen de perfil

Repaso graficos con matplotlib


Python

Publicado el 29 de Mayo del 2024 por Hilario (127 códigos)
106 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

Didáctico.


Python

Publicado el 28 de Agosto del 2023 por Hilario (127 códigos)
344 visualizaciones desde el 28 de Agosto del 2023
"""
***************************
ParaClases.py
*****************************
Hilario Iglesias Martínez
******************************
Ejemplo para clase didactica.
Descenso de gradiente para la función:
f(x)=(x**2/8) + (x**2 - 16)
**********************************************************
Inicialmente lo dejo configurado co estos parámetros:
# Parámetros que queremos aplicar para el descenso de gradiente.
---------------------------------------------------------------
learning_rate = 0.01
iterations = 10
start_x = 40
----------------------------------------
Las iteraciones ideales serías:1000.


*********************************
Realizado en
Plataforma Linux. Ubuntu 20.04.6 LTS
Editor Sublime Text.
Ejecutar en consola linux:
python3 ParaClases.py
**********************************
"""
Imágen de perfil

Derivada


Python

Publicado el 22 de Agosto del 2023 por Hilario (127 códigos)
306 visualizaciones desde el 22 de Agosto del 2023
****************************************************************
Hilario Iglesias Martínez
*****************************************************************

Programa que realiza un descenso de gradiente a una función dada.
Todos los pasos están explicados en el propio programa
Realizado en una plataforma Linux, sistema operativo Ubuntu 20.04.6 LTS.
Se utiliza b como editor Sublime Text.
********************************************************************
Para los que lo deseen pueden editar y ejecutar este programa en
Google Colab.
******************************************************************
EJECUCIÓN.
Bajo consola Linux.
python3 PyParabola.py
******************************************************************
Imágen de perfil

FTP.


C/Visual C

Publicado el 28 de Diciembre del 2022 por Hilario (127 códigos)
706 visualizaciones desde el 28 de Diciembre del 2022
-------------------------------------------------
De gustibus et colon bus non est disputandum.
----------------------------------------------
Hilario Iglesias Martínez.
--------------------------------------------
Ejemplo sencillo y práctico, modificado en
parámetros. La idea de este ejercicio está tomada
del manual "Protocolos de Internet", de los autores
Angel López, y Alejandro Novo.
Se pueden modificar y variar los códigos de respuesta.
El ejercicio funciona como cliente FTP
pasándole como parámetros, el nombre de usuario,
el password, y el nombre del servidor ftp.
---------------------------------------------------

----------------------------------------
Compilación:
gcc -o ftp ftp.c
--------------------------------------
Ejecución:
./ftp [nombre usuario] [password] [Servidor ftp]
**************************************************
sin imagen de perfil

Registro - Login - Mail - OTP


PHP

Publicado el 25 de Diciembre del 2022 por Jefferson (11 códigos)
2.095 visualizaciones desde el 25 de Diciembre del 2022

SISTEMA DE REGISTRO-LOGIN mediante EMAIL-OTP



otp_register

1) Al descomprimir hay un archivo txt que debes leer y seguir las instrucciones

-> Bien, si seguiste todos los pasos no debería petar el sistema <-

2) No posee usuario administrador (debes crearlo tu)
simplemente agregas a la tabla usuarios un campo al que puedas llamar admin tipo INT donde 1 indica que es el administrador
luego por medio de php creas controles de seguridad

3) Una vez que te logueas, recibirás un correo donde debes pulsar el botón de activar la verificación del email
(Incluye una plantilla correo para registro/verificacion email)

4) Al verificar el email el campo email_verify de la tabla usuarios cambia a TRUE o 1 permitiendo el acceso

5) Existe un campo en la tabla usuarios llamado activo tipo INT que si lo colocas a FALSE o 0 impide el acceso
(esto, por si decides crear un usuario administrador y mediante programacion php puedes darle o quitarle acceso a cualquier usuario)

6) Una vez logueado, verificado y aceptado. Puedes ingresar al sistema, no sin antes validar un codigo OTP que se te enviara
a tu correo cada vez que entres. "Incluye una plantilla correo para OTP"
(Si utilizas algun servicio SMS o WhatsApp puedes enviar ese codigo OTP por alguna de esas vias)

7) Ofrece la posibilidad de recuperar la contraseña en caso de olvido, he diseñado una password de un solo uso y que al entrar al sistema
deberias cambiarla inmediatamente. Si no lo haces esta password aleatoria quedara invalidada.

8) Al cambiar la password o contraseña por motivo de olvido, se te enviara un email notificando del cambio y te otorgaremos una nueva
password aleatoria. Si al abrir el correo no fuistes tu quien solicito el cambio de contraseña, hay un link para revertir y dejar todo
original.
(Incluye una plantilla correo para recuperacion de contraseña)
Imágen de perfil

SOCKETPAIRS


C/Visual C

estrellaestrellaestrellaestrellaestrella(2)
Publicado el 10 de Octubre del 2022 por Hilario (127 códigos)
397 visualizaciones desde el 10 de Octubre del 2022
*************************************************************************
Dulce bellum inexpertis.
************************************************************************
Hilario Iglesias Martínez

************************************************************************
Socket_Pair.c
----------------------------------------------------------------------
Este programa fue realizado en una plataforma
LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI-C,
bajo una consola Linux.
*************************************************************************
En este programa trataremos la función socketpair
que realiza un mecanismo de comunicación entre procesos,
muy parecido al de la función pipes.
La diferencia fundamental con pipes, es que la comunicación
entre procesos es bidireccional.


Esta función se encuentra en la librería <sys/socket.h>

"int socketpair(int domain, int type, int protocol, int sv[2]);"

La función socketpair() crea un par de sockets del tipo especificado
que no tienen nombre y están conectados en el dominio indicado
y utilizando el protocolo especificado.

Argumentos descripción.
----------------------
dominio:(PF_UNIX, AF_UNIX, PF_LOCAL, AF_LOCAL)
El dominio: en el que abrir el socket.
Aunque se pueden obtener pares de sockets para sockets de dominio AF_INET,
se recomienda utilizar sockets de dominio:PF_UNIX, AF_UNIX para pares de sockets.

El tipo: de socket creado, ya sea SOCK_STREAM o SOCK_DGRAM.

Protocolo:El protocolo solicitado debe ser 0.
sv:Array, con los descriptores utilizados
para referirse a los sockets obtenidos.

-----------------------------------------------------------------
Para compilar el programa se puede utilizar la utilidad make, adjunta.
También se puede compilar directamente bajo consola de linux con el comando,
teniendo en cuenta que:
Socket_Pair.c
volcado.c
variables.h
deberán estar bajo el mismo directorio.


gcc -Wall -Werror -o Socket_Pair Socket_Pair.c volcado.c

Ejecutar:

./Socket_Pair



*/
Imágen de perfil

FICHEROS-COMPORTAMIENTO


C/Visual C

Actualizado el 26 de Agosto del 2022 por Hilario (127 códigos) (Publicado el 22 de Agosto del 2022)
429 visualizaciones desde el 22 de Agosto del 2022
-----------------------------------
*

*Non scholae, sed vitae discere.**



-----------------------------------
Hilario Iglesia Martínez.
Práctica en lenguaje C.
---------------------------
Utilización y creación de Ficheros.
--------------------------------
El programa fue realizado en plataforma
LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI C.-C-11
Para ejecutar bajo consola de linux.
-------------------------------------
Otra forma de ejecución:
Si no se desea utilizar "make" para su ejecución,
y hacerlo bajo directorio en consola Linux.
Deberá estar bajo dicho directorio los ficheros: Variables.h
y main.c.
Se podrá ejecutar su compilación, según las exigencias de
depuración de la siguiente forma:
-----------------------------------------------
gcc main.c -Wall -Wextra -Werror -Wno-format -o Descriptor_Archivo
-----------------------------------------------------------
gcc -Wall main.c -o Descriptor_Archivo
-----------------------------------------
gcc main.c -o Descriptor_Archivo

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

**Descriptor_Archivo, es un programa realizado en ANSI-C, bajo LINUX,
que trata de aclarar un poco el funcionamiento de la apertura de un
pequeño fichero de texto, en el que se escribe una frase.**

**Se intenta buscar la dirección del descriptor de archivo, así como el
alojamiento de cada letra de la frase en memoria. También se hace un volcado
de la parte del alojamiento en memoria para intentar apreciar los
desplazamientos de cada letra. Al final del mismo se hace una llamada
mediante la función “system()”, para saber el PID (Identificador de proceso),
del mismo. En esta llamada podremos comprobar coincidencias en las
direcciones de memoria.**

**Al final, averiguamos con otra llamada mediante “system()”,
el inode, y la estructura de datos con la información del archivo.**
Imágen de perfil

Sobre PID y memoria


C/Visual C

Publicado el 1 de Agosto del 2022 por Hilario (127 códigos)
464 visualizaciones desde el 1 de Agosto del 2022
-----------------------------------
holodomor.c

***********************************
Programa en ANSI-C holodomor.c
Que sirve para realizar un volcado en
memoria de una palabra, con el fin de
establecer su dirección de locaclización.
así como el desplazamiento letra a letra.
Tambien realiza un dump de la parte de memoria
donde se localiza, para estudiar su posición.
Con el fin de poder apreciar el número
de proceso PID,hacemos una llamada
al comando (pmap -d).
**************************************
Este programa ha sido realizado en.
LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI C.
********************************
Compilar:
gcc holodomor.c -o holodomor
**********************************
Programado por:
Hilario Iglesias Martínez.
Cuestiones:
[email protected]
-----------------------------------
Imágen de perfil

Graficador de evolución diaria del precio de los valores en el mercado.


Python

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 21 de Enero del 2021 por Antonio (76 códigos) (Publicado el 15 de Octubre del 2020)
4.809 visualizaciones desde el 15 de Octubre del 2020
El presente programa muestra en una gráfica la evolución por días, del precio de un determinado valor, introducido por el usuario.
USO:
La información del valor se introducirá en el campo "Symbol:" (ejs: "GOOGL" para Google", "AAPL" para Apple, "TSLA" para Tesla...). Para un periodo en días que indicaremos en el campo "Time(days):" (predefinido para los últimos 90 días). Con los botones "High", "Low", "Open" y "Close", puede seleccionarse la información a mostrar (valor máximo, mínimo, de apertura y de cierre, estando el de cierre seleccionado por defecto). Con la opción "STYLE" puede cambiarse la apariencia de la gráfica. El botón "SHOW GRAPH" mostrará la gráfica en función de las entradas antes referidas. El botón "SHOW TABLE" mostrará la información en una tabla de valores (dicha tabla podrá guardarse en un documento de texto con el botón "SAVE TABLE"). Finalmente la información "BBbands" solo se muestra para determinados valores/Symbols.

Al iniciar el programa, se generará (si no está creado) un archivo, de nombre "symbols" en el que se irán almacenando las iniciales indicativas ("TSLA","^DJI","GOOGL","AAPL",NFLX","^IBEX"...) introducidas en consultas anteriores y que hayan generado algún resultado.

PARA CUALQUIER PROBLEMA, DUDA U OBSERVACIÓN, USEN LA SECCIÓN DE COMENTARIOS.

tg

dji
image3
Imágen de perfil

GRÁFICO DE VELAS (PARA ANÁLISIS FINANCIERO).


Python

Publicado el 25 de Octubre del 2020 por Antonio (76 códigos)
5.013 visualizaciones desde el 25 de Octubre del 2020
El siguiente script muestra el gráfico de velas, en el que se expresan los valores de cotización máximo, mínimo, de apertura y cierre, correspondientes a la la compañía "Apple" durante los últimos 90 días. Los datos se obtienen directamente de la página de "Yahoo finance".
appa

Figure_1