Mostrar los tags: struct
Mostrando del 1 al 10 de 20 coincidencias
Se ha buscado por el tag: struct
****************************************************************
Aequam memento rebus in arduis servare mentem
------------------------------------------------------
Hilario Iglesias Martínez
***********************************************************************
neurona.c
*****************************************************************
Este es un ejemplo de lo más básico, hecho en lenguaje C que simula una sencillisima red neuronal, y permite introducir parámetros por el teclado a través de consola linux.
Ten en cuenta que este es solo un ejemplo simple y puede requerir modificaciones o mejoras dependiendo de tus conocimientos del tema y necesidades específicas, por lo que el programa está hecho para interactuar con el, modificando parametros del mismo, como la estructura de la red neuronal,la inicialización de la red neuronal, la propagación de la misma, y el cálculo final de los valores de salida.
******************************************************************************
En principio hemos ido a un esquema sencillo, con el fin de no complicar y no hacer inentendible el programa. El esquemá básico que se propone es como sigue:
Esquemáticamente la red neuronal tiene 2 neuronas de entrada, 3 neuronas ocultas y 1 neurona de salida. Los pesos de conexión se inicializan aleatoriamente entre -1 y 1. Luego, se solicitan los valores de entrada al usuario, y se propagan hacia adelante a través de la red neuronal. Finalmente, se muestran los valores de salida calculados.
Es importante explicar un poco lo que es el peso de conexión:
-------------------------------------------------------------
Los pesos de conexión de una neurona son los valores numéricos que determinan la fuerza y la influencia de las entradas en la salida de la neurona. Cada conexión entre una entrada y una neurona está asociada a un peso.
En una red neuronal artificial, los pesos de conexión son parámetros ajustables que se utilizan durante el proceso de entrenamiento para encontrar la configuración óptima de la red neuronal. Estos pesos se actualizan iterativamente en función de la diferencia entre las salidas deseadas y las salidas producidas por la red neuronal.
Cuando se realiza una propagación hacia adelante en la red neuronal, cada neurona recibe las entradas de las neuronas previas ponderadas por los pesos de conexión. Luego, se aplica una función de activación a la suma ponderada para producir la salida de la neurona.
Los pesos de conexión se inicializan típicamente de forma aleatoria al comienzo del entrenamiento, y luego se ajustan durante el proceso de aprendizaje. El objetivo del entrenamiento es encontrar los valores de los pesos que minimizan la diferencia entre las salidas deseadas y las salidas producidas por la red neuronal.
En resumen, los pesos de conexión son parámetros ajustables que determinan la influencia de las entradas en la salida de una neurona. Estos pesos se actualizan durante el entrenamiento para optimizar el rendimiento de la red neuronal en la tarea específica que se está abordando.
--------------------------------------------------------------------------------------
El programa te pedirá que introduzcas los valores de entrada. Después de ingresar los valores, mostrará los valores de salida calculados por la red neuronal.
---------------------------------------------------------------------
Este programa fue realizado y ejecutado en una plataforma linux.
En mi caso
Ubuntu 20.04.6 LTS.
Bajo consola.
Se ha utilizado el IDE:
Sublime Text.
*************************************************************
COMPILACIÓN:
gcc neurona.c -o neurona -lm
Como ves debes agregar la opción -lm al compilar el programa.
Esta opción indica al compilador que enlace la biblioteca
matemática durante la compilación.
EJECUCION:
./neurona
**************************************
/*
-------------------------
pcap_llamadas.c
-------------------------------
Dulce bellum inexpertis.
--------------------------------
Hilario Iglesias Martínez
-----------------------------
El programa fue realizado en una plataforma
LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI-C,
bajo una consola Linux, con las
librerías libpcap cargadas
**********************************
Este programa una vez compilado
debe ejecutarse bajo administrador
principal ROOT.
************************************
NOTA:
----
Este programa es una revisión (o intento), de mejorar el ya publicado aqui.
como:"datagrama.c". Publicado el 27 de Septiembre del 2022.
Quiero indicar que como puede verse en su compilación tuve que optar
por la opcion -w, ya que la opción -Wall, da errores tipo warning,
que no he podido resolver, referentes a incompatibilidad de tipos con
la llamada "ether_ntoa() para origen y destino de identificadores
de red, tipo MAC".
En concreto:
"passing argument 1 of ‘ether_ntoa’ from incompatible pointer type"
He intentado modificar tipos, y diferentes llamadas de conversión
sin ningún éxito aparente.
Como es un programa para jugar con él, si alguién descubre la
solución, podría indicarlo.
-------------------------------------------------------------------
Compilar:
-------
gcc -w -o pcap_llamadas pcap_llamadas.c -lpcap
Ejecutar:
$ sudo ./pcap_llamadas
CAPTURA PAQUETES.
-----------------
Para agilizar la captura de paquetes,
se puede iciar la navegación por intertet.
Por defecto he configurado el puerto 443.
El tamaño del PAYLOAD recuperado está
está configurado solamente para 128 bytes.
*/
----------------------------------------------
Gaudeamus igitur iuvenes dum sumus.
----------------------------------------------
++Hilario Iglesias Martínez++
---------------------------------------------
Este programa fue realizado en una plataforma
LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI-C,
-------------------------------------------
Sencillo ejemplo sobre el manejo
en ANSI-C, de ficheros y estructuras para
colocar datos.
Este ejemplo consta de dos programas:
Escritura_Registros.c
Lectura_Registros.c
El primero:"Escritura_Registros.c", abre
un fichero de texto indicado.
-Por ejemplo: entrada-
Una vez abierto nos va pidiendo
una serie de datos para alojarlos en una estructura,
y escribirlos en dicho fichero "entrada".
Después, deberemos ejecutar:"Lectura_Registros.c"
que nos pedirá el fichero, en nuestro caso:
"entrada", y volcará por consola
los datos existentes en el mismo.
Se puede jugar con estos sencillos programas.
**************************************************************
COMPILACIÓN:
gcc -Wall -Werror -o Escritura_Registros Escritura_Registros.c
gcc -Wall -Werror -o Lectura_Registros Lectura_Registros.c
------------------------------------------------------------
EJECUCIÓN:
./Escritura_Registros
./Lectura_Registros
----------------------------------------------------------
-----------------------------------------------------
Disce quasi semper victurus vive quasi cras moriturus.
------------------------------------------------
Hilario Iglesias Martínez.
--------------------------------------------
Sencillo programa de aprendizaje,
realizado en una plataforma
LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI-C,
bajo una consola Linux.
Este programa desarrolla
la utilización de estructuras
y arrays, con el fin de confeccionar
una pequeña y sencilla base de datos.
*************************************
Se puede manipular el mismo,
modificándolo para perfeccionar
su funcionamiento.
Pueden jugar.
Compilar:
$ gcc -Wall -o seguimiento seguimiento.c
Ejecutar:
$ ./seguimiento
**************************************
Gaudeamus igitur iuvenes dum sumus.
************************************
estructura.c
-----------------------------------
Este sencillo programa, consiste en
un ejemplo de trato de estructuras apuntadas
por un puntero, y la llamada de sus elementos.
Su definición y relación con la memoria,
mostrando el volcado y su disposición
en la misma.
Se adjunta un Makefile, para poder
compilarlo a través de esta herramienta,
aunque tambien se puede realizar directamente
a través de la consola de linux con el siguiente
comando gcc:
$ gcc -Wall -o Estru_Memo estructura.c
Ejecutar:
$ ./Estru_Memo
Teniendo en cuenta que volcado.h debe
estar en el mismo directorio que
estructura.c
El programa se puede utilizar fácilmente
para el aprendizaje, modificando
parámetros y viendo su comportamiento.
+++++++++++++++++++++++++++++++++++++
Este programa fue realizado en
la plataforma:
LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI-C.
******************************************
Hilario Iglesias Martínez.
----------------------------------------Comando que muestra como exportar la estructura de una tabla para posteriormente volver a crear dicha tabla en otra base de datos.
nPrograma que dado una lista de alumnos. Devuelve la lista Ordenada por matricula
Las estructuras o structs nos permiten crear un tipo de dato único con los miembros y propiedades que queramos.. Es como tener un tipo de dato personalizado.
N Estudiantes de un grupo participan en 5 juegos de ajedrez.
Desarrolle un programa que devuelva la matricula y el nombre de los esrudiantes de mayor y
menor puntuacion
Una Empresa Avícola almacena el registro de los últimos tres años de sus gallinas ponedoras, de cada gallina se almacena su código, su peso y su edad (numero de años), Realice un Programa que calcule el promedio de sus huevos obtenidos por la empresa anualmente y el año de mayor producción
