Menú

Mostrar Mensajes

Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.

Mostrar Mensajes Menú

Mensajes - fzp

#1
Dejo aquí un método -que creo que funciona- para la resolución de un sistema de "n" ecuaciones lineales con "n" incógnitas.
Está basado en el algoritmo de Gauss (no sé si otros lo llaman de Gauss-Jordan u otros de Gauss-Jacobi). Sea como sea que lo llamen consiste en dejar la matriz de coeficientes en una matriz triangular con 0 (ceros) por debajo de la diagonal principal de a matriz de coeficientes. Y luego ir resolviendo despejando in cógnitas de atrás hacia delante.

Sé que es un método poco eficiente. Para empezar los errores de cálculos sucesivos (especialmente en sistema muy grandes con muchas ecuaciones) pueden producir desbordamientos (overflow) o que, si hay términos relativamente pequeños respecto a otros, se produzcan reducciones a "1" que desvirtúen el resultado final, para sistemas de ecuaciones muy particulares. Como mi intención es simplemente una primera aproximación para reslover sistemas del tipo de los que se dan en Ingeniería (cálculo de estructuras, mallas de tuberías, etc...) de momento éso no me importa demasiado.

También la forma de introducir los datos es totalmente ineficiente -a mano-. Es sólo para pruebas; lo suyo es que sea a partir de datos de matrices que previamente se hayan almacenado en disco. Es más, esas matrices no se introducirán a mano -ni siquiera en disco- sino que provendrán de otros programas que las habrán guardado en disco a partir de otros datos (matrices de rigidez de una estructura -de construcción- a partir de sus datos de longitud de barras, inercia, material, etc; o longitud de tubería, diámetro, material, persión, etc...).

Por lo tanto, el hecho de la forma de introducción de datos no debe de ser valorado; solo el funcionamiento del algoritmo de resolución del sistema.

Por lo tanto, respecto al programa en general, me gustaría tener opiniones sobre:
- Sobre todo: ¡fallos que pueda tener! - He probado varios sistemas, algunos con bastantes incógnitas, y los ha resuelto. He probado varios sistemas con fallos "evidentes" (filas = 0; columnas = 0; filas/columnas = combinación lineal de otras filas/columnas;...) y me los ha detectado. En ese sentido, mi miedo es más bien -no que no me detecte sistemas sin solución-, sino que sistemas que SÍ tienen solución, me los detecte como que no la tienen. ¿Veis algún fallo? ¿Alguna forma de mejorarlo?

- ¿Se podría mejorar, mediante un algoritmo iterativo, la solución? He visto cosas, pero ninguna lo suficientemente clara -para mi- sobre cómo mejorar una solución a partir de una primera solución. En concreto he leído sobre los métodos de Richardson, de Jacobi, de Gauss-Seidel, que incluso empiezan con vectores/matrices de soluciones "alejadas" de la solución verdadera; cuando se podría mplementar desde una primera solución "muy aproximada" - la que ofrece el algoritmo que aquí se da-; pero no sé como implementarla.

- Por último: sé que hay un método muy potente (y con reducción de operaciones y de tiempo de cálculo y de disminución por errores de operaciones (¡justo lo que quiero disminuir!) que es la "condensación de ecuaciones"..., pero no encuentro información viable. Si alguien me puede ofrecer literatura sobre ese tema, pues estaría genial.

Bueno, aquí dejo el código que he hecho, para las críticas/comentarios/ayudas/mejoras/etc... que creáis convenientes (cualquier cosa será bien recibida):

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

void intro_sistema (int n, double ** a);
void combina_fila (int j, int n, double ** a); // Para dejar coeficientes de la columna a cero
void intercambia_fila (int i, int j, int n, double ** a); // Para que no haya coefic. == 0 en la diagonal
void calcula_incognitas (int n, double ** a, double * solucion); // A partir de una matriz ya triangular

int main ()
{
int n; // numero ecuaciones lineales
int i, j;
double ** a = NULL; // matriz ampliada: coeficientes | terminos independientes
double * solucion = NULL;

printf ("Introducir no. de ecuaciones: ");
scanf ("%d", &n);

a = (double **) malloc ( n * sizeof (double *) ); // filas
for (j = 0; j < n; ++j)
a[j] = (double *) malloc ( (n+1) * sizeof (double) ); // columnas
solucion = (double *) malloc ( n * sizeof (double) );

intro_sistema (n, a);

for (j = 0; j < n-1; j++)  // Procesa elementos diagonal matriz coeficientes
{
if (a[j][j] == 0)
{
for (i = j+1; i < n; i++) // Busca un coeficiente de la misma columna != 0
{
if (a[i][j] != 0)
{
intercambia_fila (i, j, n, a);
break;
}
printf ("\n\nEl sistema no tiene solucion unica"); // No hay coficiente != 0 sobre el que pivotar
return 0;
}
}
combina_fila (j, n, a);
}

if (a[n-1][n-1] == 0)
{
printf ("\n\nEl sistema no tiene solucion unica\n"); // Toda la fila inferior es de ceros
return 0;
}
else
{
calcula_incognitas (n, a, solucion);
printf ("\n\n");
for (j = 0; j < n; j++)
printf ("soluc[%d] = %lf\n", j, solucion[j]);
}
return 0;
}

void intro_sistema (int n, double ** a)
{
int i, j;
double var;

printf ("\nIntroducir matriz de coeficientes del sistema de ecuaciones lineales\n");
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
{
printf ("a[%d][%d] = ", i, j);
scanf ("%lf", &var);
a[i][j] = var;
}
printf ("\nIntroducir terminos independientes del sistema\n");
for (i = 0; i < n; i++)
{
printf ("b[%d] = ", i);
scanf ("%lf", &var);
a[i][n] = var;
}
}

void combina_fila (int j, int n, double ** a)
{
double factor;
int i, k;

for (i = j+1; i < n; i++)
{
if (a[i][j] != 0)
{
factor = -a[j][j] / a[i][j];
for (k = j; k < n+1; k++)
a[i][k] = (factor * a[i][k]) + a[j][k];
}
}
}

void intercambia_fila (int i, int j, int n, double ** a)
{
double var_intercamb;
int k;

for (k = j; k < n+1; k++)
{
var_intercamb = a[i][k];
a[i][k] = a[j][k];
a[j][k] = var_intercamb;
}
}

void calcula_incognitas (int n, double ** a, double * solucion)
{
double acumulador;
int i, j;

solucion[n-1] = a[n-1][n] / a[n-1][n-1];
for (i = n-2; i >= 0; i--)
{
acumulador = a[i][n];
for (j = i+1; j < n; j++)
acumulador = acumulador - (a[i][j] * solucion[j]);
solucion[i] = acumulador / a[i][i];
}
}


Pues nada, lo dicho, que se agradece cualquier comentario.
#2
Cita de: Serapis en 13 Diciembre 2021, 18:09 PM
...
Olvidaba decirte, que en realidad si se puede hacerse el cálculo más abreviado para saber si el grafo es conexo o no, pero sólo en el caso de que sí lo sea, si no lo es, exigirá todo el recorrido igualmente...

...Para ello, basta señalar como regla que cuando si pila alcance el número de nodos del grafo, entonces se demuestra que es conexo y puede salir y evitar el resto del recorrido ...(solo los numnodos de retornos)...

Efectivamente, tienes toda la razón; no me había dado cuenta de ésto. Se puede terminar -en determinados caso que son los que dices- el algoritmo.

Por demás, decir que ya sé que no he entrado a fondo en los grafos. Sé que para para lo que realmente se usan hay que tener en cuenta las consideraciones que haces.

Lo de que hay que meter (en mi mini-programa) toda la matriz tampoco es así. Si ves el código, al crear la matriz de adyacencia (ahora sí lo he escrito bien  :D ) se inicializa a pesos = 0; o sea, por defecto todos los nodos están desconectados entre sí, y sólo hay que meter los que sí están conectados (dando un peso != 0). Siempre que el grafo pueda ser representado en un plano, no hay saltos tridimensionales (fuera del plano) de un nodo a otro, que son los grafos que me interesan; o sea que un nodo solamente estará conectado a un nº pequeño de otros nodos  (respecto del total de nodos), con lo cual solo hay que meter un pequeño número de conexiones de un nodo con otros.

Lo que no quita que, efectívamente, para aplicaciones prácticas de grafos (utilidades reales en la práctica), lo que comentas de buscar un método efectivo de almacenamiento en disco -por ejemplo en forma de texto- sean lo deseable. Ficheros que, una vez transformados a formatos entendibles por el programa, puedan ser tratados por éste.

Por ejemplo, me parece (sólo me parece) que el formato de los procesos padre|hijo, etc, me da la impresión de que podría ser parecido al concepto de "lista de adyacencia" (en lugar de la matriz). Aunque es sólo la impresión. La verdad, me cuesta un poco entender el concepto padre/hijo. Medio lo puedo entender en bifurcaciones en rama (árbol), pero en mallas (ejemplo simple: triángulos conectados en un plano) me cuesta más entender el concepto de padre/hijo. Y aún comprendiéndolo en bifurcaciones tipo rama de árbol, no consigo -aún, espero que algún día sí- comprender cómo se configuran dentro de un lenguaje.

No he profundizado más porque tampoco los grafos eran mi interés primordial. De hecho sólo me ha interesado la parte de "recorrer el grafo", porque me ha parecido que los grafos son una forma de aproximación (creo pero solo intuitívamente) que algo tienen que ver con los recorridos de laberintos (recorrer laberintos al azar y/o crear laberintos geométricos aleatóriamente). Por éso sólo me ha interesado la conexión entre nodos (SI/NO representada por un peso == 0 | != 0), y no el significado de esos pesos y la forma de maximizarlos/minimizarlos (por recorridos). Y por éso la forma que se me ocurrió de abordar el problema era la matriz, antes que la topología del grafo.

De todas formas, ha sido super-instructiva tu colaboración, una vez más, gracias.


#3
¡Brutal!
El que quiera entender, que entienda.
Ahora ya no vale: ¿por dónde empiezo?... ¡Joé! Pues empieza por dónde quieras, ¿Será por material?

#4
Cita de: Tachikomaia en 28 Diciembre 2021, 00:51 AM

¿Aunque no estés registrado puedes ver la lista de sus mensajes?


¿Quién te ha dicho que yo no esté registrado?  :silbar:

La cuestión es que si tu tienes otra fecha para el último mensaje del tal Cell distinta de la que yo he puesto la digas. ¿fue su último mensaje en la fecha que yo he dicho o hay mensajes posteriores? Y si es así, ¿de qué fecha es su último mensaje? Fácil, ¿no?
#5
Hay algo que no entiendo Tachikomaia. Como ya ha indicado el forero #!drvy tú citas a ese forero en tu firma en ese foro; es el usuario Cell -creo-, del cual tú pones en tu firma:

PD: No miro la basura que Cell dice.

Sin embargo, algo no cuadra. Tu primer mensaje -en este foro- relativo a la "supuesta" persecución que te hace es de fecha 8 de Diciembre 2021, 05:31 am :

https://foro.elhacker.net/foro_libre/iquestque_puedo_hacer_contra_un_nazi_que_me_acosa_en_otro_foro-t513169.0.html

Pero resulta que el último mensaje de ese forero que "supuestamente" te persigue y te cita en ese foro sofosag... etc, es de... 30 Jun 2021, 02:17. Y por cierto, no habla nada de ti.

Así que dices que alguien te persigue cuando... hace más de cinco (5) meses que no es que te cite -a ti personalmente-, sino que no ha citado a nadie ni ha dicho nada desde 30 Jun 2021, 02:17; porque ésa es la fecha de su último mensaje.

Tú mismo comprenderás que hay algo que no cuadra en tu mensaje de "supuesta" persecución...
#6
Cita de: MinusFour en 24 Diciembre 2021, 04:46 AM
Que yo sepa no existe esa regla. Lo que si no se puede hacer es crear una cuenta secundaría para evadir un ban.

No sé si lo he entendido del todo. Entonces... ¿yo puedo crear cuantas cuentas quiera... siempre que no sean para evadir un ban?

Y supongo que lo que se quiere decir es que no exista un ban previo porque, en realidad, nadie sabe para  qué me creo una cuenta en un momento dado, y supondría un juicio de intenciones sobre mis (supuestos) motivos para crearme una nueva cuenta. Igual estoy baneado pero el motivo de crearme una nueva cuenta no es eludir el ban (¿quién carajo sabe cuáles son mis motivos?). Serían de desear normas más claras. la precisión nunca está de más. Especialmente cuando se refieren a reglas y normas de comportamiento -en un lugar común- que todo el mundo ha de cumplir.



#7
Bueno, una cosa sí que es segura. No tengo ni idea de si se refiere a Hason, o a un inexistente Jason. Pero lo que sí es cierto es que el usuario FreddyKrueger NO ESTABA en Mayo de 2019, dado que se ha registrado el 23/12/2021 a las 00:50.

https://foro.elhacker.net/profiles/freddykrueger-u609251.html

Por tanto sólo hay DOS OPCIONES -en buena lógica-: o el usuario que se hace llamar FreddyKrueger está mintiendo, y jamás tuvo ninguna trifulca con otro usuario -ya fuera éste Jason o Hason- o, si la tuvo, for fuerza debió de ser con otro nombre de usuario, y entonces... el usuario FreddyKrueger está incumpliendo las normas del foro por usar -al menos, y que sepamos- dos cuentas diferentes con dos alias (nicks) diferentes (el actual .FreddyKrueger y el que tuviera en Mayo de 2019 cuando la supuesta pelotera con Jason/Hason).

Eso sí que es seguro, si usamos la lógica: sólo cabe una de esas dos posibilidades.
#8
¿Y no se puede cortar el sonido?
#9
¿Has probado con Kali en USB -arrancable- en lugar de Vbox? ¿Te pasa lo mismo?
#10
Dudas Generales / Re: ¿Por dónde empiezo?
22 Diciembre 2021, 23:17 PM
Cita de: theowl en 22 Diciembre 2021, 23:08 PM
, por dónde empezar?,

Por leer las reglas del foro, y revisar las consultas que ya se han hecho. Pero éso no para el asunto que te ocupa (llámalo hacking o seguridad informática o como quieras) sino para todo en la vida, muy especialmente para participar en un foro.

Verás que esa pregunta ya ha sido hecha y contestada cómo unas cincuenta mil veces... Pues léete esas preguntas y respuestas.

¡Por ahí es justo por donde debes de empezar! Por leer reglas del foro y preguntas/respuestas que ya hayan sido hechas. Y cuando hayas terminado... Google.

De nada.