Mostrar los tags: C

Mostrando del 21 al 30 de 2.858 coincidencias
Se ha buscado por el tag: C
Imágen de perfil

COPIAR PESTAÑAS DE UN LIBRO DE EXCEL A OTRO


Excel

Publicado el 24 de Noviembre del 2024 por Demon Jr (6 códigos)
799 visualizaciones desde el 24 de Noviembre del 2024
EL EJEMPLO TRATA SOBRE COMO COPIAR CIERTAS PESTAÑAS DE UN LIBRO DE EXCEL EN UN NUEVO LIBRO (RECIEN CREADO)
PODRIA SER UTIL EN EL CASO QUE TENGAS UN ARCHIVO
DINAMOCO Y TENGAS QUE ESTAR GENERANDO REPORTES
ya metiéndole mas coco le puedes agregar instrucciones y guardarlo donde gustes.
es solo un ejemplo básico que espero le sea util a alguien
Imágen de perfil

3 en raya


C/Visual C

Actualizado el 30 de Octubre del 2024 por Adelino (27 códigos) (Publicado el 27 de Agosto del 2024)
5.594 visualizaciones desde el 27 de Agosto del 2024
Juego de Tres en raya en pantalla de texto.
Screenshot_20240828-012423_lDosBox
Imágen de perfil

Partículas


Python

Actualizado el 12 de Septiembre del 2024 por Hilario (143 códigos) (Publicado el 4 de Septiembre del 2024)
479 visualizaciones desde el 4 de Septiembre del 2024
Oxigeno

****************************************************************************************************************
Aula_18_Apli_Sep_Schrodinger_Oxigeno.py
***************************************

Proponemos, para el Aula 18, dentro del tema de la ecuación de Schrödinger, una aplicación realizada en lenguaje Python, donde aplicamos la ecuación de Schrödinger, para determinar la posible posicion sobre un electrón de la primera capa en un átomo de Oxigeno.

Explicación del Código

Parámetros y constantes:
Se definen las constantes físicas necesarias como la constante de Planck reducida (hbar), la carga del electrón (e), la masa del electrón (m_e), la permitividad del vacío (epsilon_0), y el número atómico del oxígeno (Z = 8).

Malla radial: Se crea una malla en el espacio radial para resolver la ecuación diferencial utilizando el método de diferencias finitas.

Potencial coulombiano: Se calcula el potencial de Coulomb debido al núcleo, que es la parte central de la energía potencial en el sistema.

Matriz Hamiltoniana: Se construye la matriz Hamiltoniana usando diferencias finitas.
Resolución de la ecuación de Schrödinger: Se obtienen los autovalores y autovectores de la matriz Hamiltoniana. El autovalor más bajo corresponde a la energía del estado fundamental (1s).

Normalización y cálculo de la probabilidad radial: La función de onda se normaliza y se calcula la densidad de probabilidad radial.

Gráfica: Se grafica la densidad de probabilidad radial en función de la distancia radial.
Consideraciones
Este código resuelve la ecuación de Schrödinger para un electrón en un campo de Coulomb, que es una aproximación simplificada para el átomo de hidrógeno. Para el átomo de oxígeno, este modelo no considera las interacciones electrón-electrón ni la repulsión entre electrones, pero proporciona una idea básica sobre la distribución de probabilidad de un electrón en el orbital 1s.

Este programa aplica muy básicamente la ecuación Schrödinger, explicando una forma de iniciación
que resuelve la posivilidad probabilistica de encontrar la párticula, como se puede ver en el gráfico resultante.

Durante el código, explicamos lo más conciso posible los pasos más importantes. En el aula, durante la segunda semana de spetiembre trataremos de explicar el resto de las dudas, así como aumentar la complejidad del
código para acercarlo lo más posible a la realidad CUÁNTICA.

-----------------------------------------------------------------------------------------------------
Programa realizado bajo Linux, sistema operativo: Ubuntu 20.04.6 LTS.
Editor Sublime text.
Ejecución:python3 Aula_18_Apli_Sep_Schrödinger_Oxigeno.py
Imágen de perfil

Generador de gifs a partir de video, en línea de comandos.


Python

estrellaestrellaestrellaestrellaestrella(7)
Actualizado el 26 de Agosto del 2024 por Antonio (77 códigos) (Publicado el 9 de Diciembre del 2022)
11.171 visualizaciones desde el 9 de Diciembre del 2022
Programa para generar gifs animados a partir de vídeos, que se ejecuta en la línea de comandos.
ARGUMENTOS:
-src/--source: Nombre del vídeo original (obligatorio).
-dest/--destination: Nombre del archivo a generar (opcional).
-sz/--size: Tamaño en porcentaje del gif respecto al vídeo original (opcional).
-shw/--show: Muestra resultado en ventana emergente al finalizar el proceso de generado (opcional).
-st/--start: Segundo inicial para gif (opcional).
-e/--end: Segundo final (opcional).
-spd/--speed: Velocidad relativa de la animación (opcional)

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

mk
Imágen de perfil

Generador de Contraseñas


PHP

Publicado el 11 de Agosto del 2024 por Javier (2 códigos)
632 visualizaciones desde el 11 de Agosto del 2024
generador

Hola a todos aqui les dejo un generador de contraseñas que escribi en php, boostrap, css y javascript
Imágen de perfil

Visor de gráficos financieros (nueva versión)


Python

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 24 de Julio del 2024 por Antonio (77 códigos) (Publicado el 18 de Abril del 2022)
4.906 visualizaciones desde el 18 de Abril del 2022
Programa para mostrar el precio de cierre, apertura, máximo y mínimo de las acciones de un activo para un determinado periodo de tiempo. También incluye representación de 'bandas de bollinger' y la media movil de 20 sesiones. Para mostrar la gráfica correspondiente a la información deseada, hacer click en el botón 'SHOW GRAPH'. Para cualquier duda u observación, utilicen la sección de comentarios.
fg
Imágen de perfil

Lector, por cámara, de códigos "QR"


Python

estrellaestrellaestrellaestrellaestrella(12)
Actualizado el 14 de Junio del 2024 por Antonio (77 códigos) (Publicado el 22 de Abril del 2020)
44.572 visualizaciones desde el 22 de Abril del 2020
El programa tiene como objeto principal, la lectura, haciendo uso de la cámara web, de códigos QR. Para ello, simplemente pulsaremos el botón "INICIAR LECTURA POR CAMARA" (que desplegará el visor de la cámara) y colocaremos el código a leer, delante de la cámara. A su vez, también podremos leer códigos QR, en formato "png" y "jpg" almacenados en nuestra computadora (para lo que usaremos la opción "CARGAR ARCHIVO". Finalmente, también podremos leer, directamente, un código que se encuentre visible en pantalla (botón "DETECTAR EN PANTALLA").

qrcc
qrcm1
Imágen de perfil

Red Neuronal CNN, selección de características.


Python

Publicado el 3 de Junio del 2024 por Hilario (143 códigos)
497 visualizaciones desde el 3 de Junio del 2024
imagen
Figure_1

***********************************************************************************************************************
------------------------------------------------------------------------------------------------------------------------------------------






Aula_28_Aprendizaje_RedNeuronal_CNN.py
-----------------------------------------------------------
**************************************************

Pretendemos alojar en esta ruta de mi ordenador:/home/margarito/python/PetImages, el directorio PetImages, que a su vez contiene otros dos directorios con el nombre cat y dog. Los mismos contienen imagenes de gatos y perros. Vamos a construir una red neuronal convolucional, que dada la imagen en esta ruta:/home/margarito/python/imagen.jpeg, determine si pertenece a un gato, o a un perro. También s deberá mostrar la imagen.

Lo primero que debemos hacer es el código que descargará los datos.

# Descargar el archivo de datos
url = "https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_5340.zip"
filename = "kagglecatsanddogs_5340.zip"
r = requests.get(url)
with open(filename, 'wb') as f:
f.write(r.content).
------------------------------------------------------------------------------------------------------------------------
Las partes del ejercicio a resaltar, son las siguientes:

En general, este ejercicio describe el proceso completo de implementación de una red neuronal convolucional (CNN) usando TensorFlow para clasificar imágenes de gatos y perros. A continuación se presenta un resumen de las partes más importantes:

1. Configuración Inicial y Descarga de Datos.
---------------------------------------------------------------
Se importa TensorFlow y otras bibliotecas necesarias.
Se descarga el dataset de gatos y perros desde una URL proporcionada y se descomprime en el directorio de trabajo.

2. Preparación de los Datos.
------------------------------------
Verificación de Imágenes: Se recorren las carpetas de imágenes para verificar que no haya archivos corruptos y se eliminan los que no son válidos.
Organización del Directorio: Se aseguran que las carpetas para las categorías cat y dog existan en el directorio base.

3. Preprocesamiento de los Datos.
---------------------------------------------
Se utiliza ImageDataGenerator para realizar una reescalado de las imágenes y dividir el conjunto de datos en entrenamiento y validación.
Generadores de Datos: Se crean generadores de datos para el conjunto de entrenamiento y de validación, especificando
el tamaño de las imágenes, el tamaño del batch, y el modo de clasificación binaria.

4. Construcción del Modelo CNN.
-------------------------------------------
Se define una arquitectura secuencial de la red neuronal con capas de:
Convolución: Tres capas convolucionales con activación ReLU.
Max-Pooling: Después de cada capa convolucional.
Flatten: Para convertir los mapas de características 2D a un vector 1D.
Densa: Una capa densa con 512 neuronas y activación ReLU.
Dropout: Con una tasa del 50% para reducir el sobreajuste.
Salida: Una capa de salida con activación sigmoide para la clasificación binaria.

5. Compilación del Modelo.
-----------------------------------
El modelo se compila utilizando el optimizador Adam y la función de pérdida de binary_crossentropy, con métrica de precisión.

6. Entrenamiento del Modelo.
------------------------------------------
El modelo se entrena durante 10 épocas utilizando los generadores de datos creados anteriormente.
Se calculan los pasos por época basados en el tamaño del conjunto de entrenamiento y validación.

7. Evaluación del Modelo.
--------------------------------------
Se evalúa el modelo usando el conjunto de validación y se imprime la precisión de validación.

8. Predicción de Nuevas Imágenes.
----------------------------------------------
Se carga una nueva imagen, se preprocesa y se realiza una predicción utilizando el modelo entrenado.
Se muestra la imagen junto con la predicción (gato o perro).

9- Características del EQUIPO donde se realizó el ejercicio.
----------------------------------------------------------------------------------
El ejercicio fue realizado en una plataforma Linux.
Con el sistema operativo Ubuntu 20.04.6 LTS.
Editado con Sublime text.

El adware del mismo es:
------------------------------------
Intel® Core™ i5-10400 CPU @ 2.90GHz × 12
Intel® UHD Graphics 630 (CML GT2)

Para llegar a esta exactitud o accuracy
157/157 [==============================] - 9s 56ms/step - loss: 0.8151 - accuracy: 0.8177
Validation accuracy: 81.77%, tardamos 2258.9 segundos.

Como se puede apreciar, mucho tiempo de ejecución, y muy forzado el equipo a dedicación completa.

------------------------------------------------------------------------------------------------
Ejecución bajo consola Linux:
python3 Aula_28_Aprendizaje_RedNeuronal_CNN.py.
Quien desee salvar el modelo, para experimentar con él
puede hacerlo añadiendo esta línea de código
a continuación del proceso de compilación:
# Guardar el modelo
model.save('modelo_cnn_gatos_perros.h5')
# Guarda en formato HDF5, indicando la ruta de tu ordenador donde se desee salvarlo.