Mensajes

La teoría cuántica de hecho falla, por eso se eligen otros modelos para explicar los casos que la mecánica cuántica no puede, caso de la gravitación cuántica. Y me permito decir que la "herramienta" de Schröedinger es una función probabilistica, tanto como eso puede llamársele "precisa" o "ley", más decir que no es la forma más completa que conocemos, puesto que Dirac la corrigió para agregar las consideraciones relativistas debidas a la velocidad, que dilata el tiempo.

Otro punto: El que los instrumentos de medida no sean capaces de medir "impunemente" no es un error, de hecho se puede probar matemáticamente en cualquier caso y es cierto. El principio de incertidumbre aplica a la medición de la posición y velocidad de un electrón como aplica a la confección de una matriz de datos para evaluar la productividad marginal de una máquina, o en cualquier caso donde decidamos medir.

El caso es: ¿Podemos resolver sistemas caóticos con finitas pero muchas variables, y hacerlo con precisión infinita?

La respuesta es "no", seco y rotundo, por eso una parte muy importante de la medición es el cálculo de propagació de errores. No podemos y no hay una forma matemáticamente posible de hacerlo, a menos que seamos omniscientes.

¿Se trata de alguna magia, flexibilidad o imprevisibilidad del universo?

Realmente no lo sabemos y tampoco somos capaces de averiguarlo, porque aunque el universo no fuera imprevisible, si fuera deterministico como pensaba Laplace, seguirímos siendo incapaces de demostrarlo porque no podemos recolectar los datos iniciales sin afectar unos a otros mientras los medimos, así tuvieramos un ordenador capaz de computar el universo mismo, es imposible recolectar los datos iniciales.

Por eso procedemos a estimar resultados a los plazos que podamos con conjuntos de datos que somos capaces de medir. Aunque nos aproximaremos más al valor real cuantos más datos medimos, también llegará el punto en que intentar medir más valores afectará más y más a los demás valores medidos, haciendo inútil recoger más datos. Simplemente no es matemática ni físicamente (valga la redundancia semática) posible obtener todo el conjunto, estarías en el dilema de Heisenberg (y no hablo de crear un imperio de drogas para proveer a tu familia).

Valga decir, o repetir, último, que si bien PI es irracional y podemos tener largos trances intelectuales con ella, tiene una expresión integral que, en muchos casos, se puede usar para resolver problemas sin necesidad de usar el número PI. Lo mismo con la expresió de 'e' como un límite.

¿A qué te refieres con 'texto de largada'?

¿Podrías hacer una especie de simulación de lo que introducirías, y lo que esperas obtener? A veces lo más difícil de hacer un programa es entender qué es lo que la gente pretende que haga.

Si te explicas mejor, sería más fácil.

Todo viene a desconocimiento de las variables. No significa ni prueba que las leyes sean inexactas, ni mucho menos que no existan leyes universales, si es el punto.

Pasamos de hacer esa pregunta a hablar de sistemas caóticos, donde el aspecto principal de las desviaciones es la imposibilidad de conocer con certeza los valores iniciales.

No es lo mismo, pero pensemos que intentamos descifrar un mensaje inmenso de la naturaleza cifrado con un simple XOR, con una clave inmensa. Entendemos que la ley para desencriptarlo parece un simple XOR, y tras varios intentos obteniendo mensajes descifrados parcialmente podemos pensar que no es posible descifrar todo, o que el método debe ser diferente, o que simplemente hay algo raro en el mensaje de la naturaleza que hace que cada intento haya alguna complicación nueva. En realidad, solo es necesario llegar al pass completamente correcto. Hasta que no lo hagamos, obtendremos resultados parciales.

Algo así sucede cuando intentamos comprender sistemas con muchísimas variables (pero finitas), mientras lo simplificamos a tantas como podamos procesar. Sucede que nos encontramos con resultados parciales, y podemos caer en el error de pensar que hay algo mágico, que no hay manera de tener una ley completa. Simplemente se trata de potencia de cálculo, conocimiento de las variables.

Y ahí la completa realidad del principio de incertidumbre, volviendo al clima, podríamos pensar que poner anemómetros en cada lugar del mundo nos permitiría pronosticar con exactitud. No, en ese caso deberíamos cambiar todas las leyes que usamos para considerar la pérdida de energía del viento al pasar por tantos aparatos. Porque cada vez que metemos nuestra nariz para medir algo, lo modificamos.

Lo mismo con el tema de medir la tensión, o diferencia de potencial eléctrico, como desees llamarle, en realidad consideramos que el Voltímetro (o Multímetro / Polímetro) es un aparato con resistencia infinita, que todo el flujo pasa por las mallas y que el aparato no es una malla más. Mentira, esa es una aproximación conveniente. La realidad es que meter el aparato modifica al sistema ligeramente, porque para funcionar necesita pasar una corriente.

No somos capaces de recoger datos impunemente, pero eso no significa nada respecto de las leyes.
No somos capaces de procesar inmensidad de datos correctamente, pero eso no significa que no puedan ser procesados.

El universo no es contínuo, si usas tantos decimales como para llegar al nivel atómico, no creo que requieras más. De otra forma siempre se puede dejar la expresión integral de PI y resolver, si se puede, mediante algún método más avanzado.

En realidad no creo que se pueda hablar mucho sobre este tema sin mencionar que, a ciencia cierta, no conocemos nuestro universo tanto como para responder.

Aún así, de lo que conocemos, planteas un panorama un poco confuso para mi punto de vista, o un punto de vista con otra perspectiva del mismo universo (una perspectiva que me parece confusa).

La gravitación de Newton es una aproximación demasiado básica como para hablar de la realidad o falsedad de ella, es un caso particular en determinadas condiciones, y si las condiciones son parte de la ley, entonces la ley no se trata como universal. Lo era, hasta que se debió corregir. Nadie hoy dia pretende que lo sea. Estaba muy bien cuando pensábamos que la gravedad afecta a distancia e instantáneamente, estaba muy muy bien cuando pensábamos que el espacio-tiempo era tan "chato". La gravitación más completa aplica a todos los niveles, y con eso quiero decir que teóricamente es A TODOS. Eso a menos que los muchachos que estudian la teoría de cuerdas determinen que a niveles muy muy muy pequeños no obtenemos el resultado esperado. Pero aún así hay una explicación razonable y es que nosotros simplificamos la medición a las dimensiones que conocemos. Solo se requiere ampliar las dimensiones y se obtiene un resultado completo. Quiero decir, no vale agarrar las leyes de Newton y usarlas para decir que las leyes se violan.

El tiempo... el tiempo no es para nada constante, no se trata solo de cómo lo experimentes, no es una coordenada unidimensional contínua. Lo que sucede y por lo que lo podemos usar para medir, es que la forma en la que cambia tampoco es aleatoria, nos permite establecer quién es el pasado, presente y futuro y hacer cálculos con ello. No estoy confundiendo causalidad con determinismo, que no sea aleatoria no quiere decir que sea predecible.

Lo del vacío cuántico es muy explicable.. Einstein mismo dijo que lo habían interpretado mal cuando empezaron con la teoría cuántica y todas estas salsas modernas. Y se murió de viejo, de haber tenido más vida quizá hubiera llegado a demostrar su punto. A ver, la ciencia que de tanto conocer se jacta no tiene la menor idea de si nuestro universo forma parte de un multiverso o si existen dimensiones muy cerca de la nuestra que la afectan. No tenemos la menor idea de lo que hacen los quarks cuando de momento desaparecen y aparecen en otro lado ¿Qué si fuera el mismo efecto de una onda en Z atravesando el mundo plano X-Y? ¿Qué si nuestro X-Y-Z es solo una instancia donde otra dimensión es fija y los quarks pueden moverse en ella? Y si hubiera ... más de 9000! dimensiones? jaja! no pude evitarlo...

Quiero decir, no conocer todo el sistema no hace que las leyes que formulamos sean falsas, simplemente podemos mostrar que son incompletas. Y, de nuevo, no por esto debemos pensar en el determinismo, el que haya algunas leyes universales no hace a la correspondencia biunívoca entre causas y consecuencias, aún si fuera cierto.

Excelente respuesta la de Yoel, muy completa.

Agrego algo más técnico, por si interesa:

Si descendemos al nivel de la implementación, las llamadas a funciones de C meten los parámetros en la pila (push). La función sabe cuánto debe sacar de la pila para ser usado como parámetro (exceptuamos acá las funciones variádicas), esto porque le dijimos al compilador de C el tipo de cada parámetro y, con ello, su tamaño.

Imagina ahora que le pasamos str, que es un char[]. Si pasáramos toda la cadena por 'valor' a la función, cada cadena podría meter una cantidad de carácteres diferente a la pila, para lo cual la función debería sacar carácter por carácter de la pila, verificar que no sea un '\0' y seguir. No es que sea imposible, pero es algo sucio y que no sigue la línea de comportamiento de las llamadas donde se pasa un vector cualquiera, digamos, de enteros, que se pasan por referencia. La función ciertamente NO tiene idea de cómo saber dónde terminar de procesar un vector de enteros (se podría, pasando el tamaño, pero eso ensucia más la convención, y queremos mantener las cosas simples).

Por eso dentro de la convención de llamadas a función de C se eligió la forma más sencilla y comprensible posible: Cualquier cosa que sea un vector (blabla[]) se pasa por referencia a las funciones, esto es, se pasa un puntero. De esa forma las funciones saben que deben sacar de la pila un puntero, que es siempre del mismo tamaño, tamaño dirección de memoria del sistema.

En las funciones variádicas nosotros podemos sacar parámetros de la pila como nos de la gana, y eso nos permitiría pasar un string por valor. Sin embargo, cuando pases un char[], notarás que NO se mete la cadena en la pila del sistema, aunque uses varargs la cadena simplemente no está ahí, y esto es porque cuando el compilador de C lee que pasa un char[], mete el puntero a la pila. Está programado para hacer eso.

Saludos, espero haber agregado conocimiento y no dudas.

[VITAL]

Le di una repasada, quedan unos warnings que es VITAL corregir para algún lado, porque el uso de isalpha() es muy incorrecto.

Por favor ver los comentarios que hice al código. Traté de adaptar los comentarios a un estilo C más purista, corregí algunas cosas sencillas, pero hice muchos comentarios de cosas que quedan por corregir, si las hubiera corregido todas no hubieran reconocido el código que había.

Revisar y mejorar, por favor. Con gusto vuelvo a verlo cuando esté corregido. Muy importante lo de los isalpha().

Código (c) [Seleccionar] Expandir

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



/**
*  D4RIO: Usar enums en lugar de macros del preprocesador
*  ayuda a la hora de usar un debugger, ya que estos símbolos
*  forman parte de la tabla de símbolos del programa
*/
enum { MAX_LEN_STR_AGENDA = 10 };
enum { MAX_REG_AGENDA = 10 };



/* defino una estructura  llamada agenda */
struct agenda {
 int codigo;
 char nombre[MAX_LEN_STR_AGENDA];
 char apellido[MAX_LEN_STR_AGENDA];
 int telefono;
 int vacio;
} registros[MAX_REG_AGENDA];



/**
* funciones a utilizar
*
* D4RIO: A la hora de crear prototipos de funciones, notar que para
* C un parentesis vacio no significa precisamente que la funcion no
* recibe parametros. Usar (void) para ser específico sobre esto.
*/
int ingresar(int codigo, int pos);
void consultar(void);
int verifica_pos(void);
void desmarcar_pos(void);
int verifica_cod(int cod);
int excluir(void);
void mostrar(void);



int
main(void)
{
 int op, retorno, codaux, posicion;
   
 desmarcar_pos();  /* no entiendo bien para que sirve esta funcion */

 do {
printf("\n\n\t\t\t\t** AGENDA **\n1 - Ingresar\n2 - Buscar\n3 - Borrar\n4 - Mostrar todo\n\nOpcion: ");
scanf("%d", &op);

while(getchar() != '\n');
   
switch(op) {
case 1:                
 posicion = verifica_pos();
 if (posicion != -1) {
printf("\nIngresar codigo: ");
scanf("%d", &codaux);
while(getchar() != '\n');
   
retorno = verifica_cod(codaux);
if(retorno)
 ingresar(codaux, posicion);
else
 puts("\nIntenta de nuevo");
 }
 else
puts("\nLa agenda ya esta llena");
 break;
case 2:              
 consultar();
 break;
case 3:
 excluir();
 break;
case 4:
 mostrar();
 break;
case 5:
 puts("\nPresione INTRO para salir");
 getchar();
 break;
default:
 printf ("\nEsa opcion no existe");
 break;
}
 } while(op != 5);
}



/* adecuacion de la declaracion de funciones a lo usual */
void
mostrar()
{
 /**
  * Aqui tengo que mostrar todo pero sin el dato eliminado ya que me
  * muestras todo  seria con registros[pos].vacio == 1 pero
  * no se como muy bien
  */
 int cont = 0;
   
 while (cont < MAX_REG_AGENDA) {
printf ("\n\t ----------------");
printf ("\n\t posicion %d",cont);
printf ("\n\t codigo   %d",registros[cont].codigo);
printf ("\n\t nombre   %s",registros[cont].nombre);
printf ("\n\t apellido %s",registros[cont].apellido );
cont++;
 }
}



/**
* D4RIO:
* Notar que si ya habia un prototipo no es necesario declarar el tipo de datos de los parametros.
* De hecho es lo mismo si se ponen los tipos abajo de la declaracion de la funcion.
*
* adecuacion de la declaracion de funciones a lo usual
*/
int
ingresar(codigo, pos)
{
 int val_atomic;
 int val_atomic2;
 int estado;
 int estado2;
 /* D4RIO: faltaba declarar suma */
 int x, y, suma;
 int i;
   
 if(pos > MAX_REG_AGENDA) {
puts("\nTodo esta lleno");
 }
 else {      
registros[pos].codigo=codigo;
val_atomic = 0;
val_atomic2 = 0;
estado = 0;
estado2 = 0;  
do {
 if(!estado) {
printf("\n Nombre: ");
/**
* utilizo scanf ya que no se utyilizar muy bien el gets creo que hice lo correcto
*
* D4RIO: Tampoco deberias usar scanf, es posible que tengas buffer overflows,
* la mejor opcion es usar una biblioteca como GNU readline, otra opcion es fgets.
* ADEMAS, estabas usando &registros[pos].nombre, que es un puntero a un puntero,
* fijate que en otro comentario te lo explico, pero para C, las referencias a
* arrays son punteros cuando se pasan a funciones. La forma correcta de llamar es
* darle la direccion de memoria del primer caracter:
*
*    &registros[pos].nombre[0]
*
* o bien de esta forma, que es igual:
*
*    registros[pos].nombre
*/
scanf ("%s", registros[pos].nombre);
 }
 else {
if(val_atomic == 1) {
 /**
  * D4RIO:
  * Por favor, usar puntuacion, originalmente aqui decia:
  *
  *    Nombre correcto no es necesario modificar
  *
  * Es inaceptable que no se use puntuacion, afecta la semantica.
  * Les dejo un ejemplo:
  *
  *    El director, dice el maestro, es un burro
  *    El director dice: el maestro es un burro
  */
 puts("\nNombre correcto, no es necesario modificar");  
 x = 1;
}
 }
 if(!estado2) {
printf("\n Apellido ") ;
scanf("%s", registros[pos].apellido);  
 }
 else {
if (val_atomic2 == 1) {
 /**
  * D4RIO:
  * Mismo comentario sobre la puntuacion
  */
 puts("\nApellido correcto, no es necesario modificar") ;  
 y = 1;
}
 }
 /**
  * D4RIO:
  * Lo que haces en estas dos lineas que siguen es declarar dos punteros
  * a char (que se interpretan en C como strings), y apuntarlos al comienzo
  * de los strings nombre y apellido de la posicion 'pos' del array de
  * objetos del tipo estructurado 'struct agenda' (relee si no entiendes)
  */
 /* se supone que paso lo que esta en la estrctura d de nombre a un puntero */
 char *str = registros[pos].nombre;
 char *str2 = registros[pos].apellido;
 i = 0;
 /**
  * no entiendo bien pero se supone que un puntero es un array
  * pero  no se como funciona el while aqui
  *
  * D4RIO:
  * Un puntero es un puntero, punto. Cuando apunta al inicio de una cadena
  * de caracteres se usa como un manejador de esa cadena. No podemos andar
  * pasando arrays completos de aqui para alla, asi que se usa un puntero
  * porque ocupa menos espacio, basicamente. De hecho, C maneja a muchos fines
  * registros[pos].nombre como un puntero a &registros[pos].nombre[0]
  *
  * Y no, el while aqui NO funciona, no lo corregi para que lo veas, porque es mas
  * que evidente, el flujo del segundo 'if' va por el 'if' o por el 'else',
  * por uno de los dos seguro, y en cualquiera de los dos hay un break, con lo
  * que poner un while es inutil. Nunca pasara mas de una vez.
  */
 while(str) {
/**
* Digo que si cadena es mayor a 10 entonces que no se pueda exceder del tamaño del array
*
* D4RIO: Esto basicamente esta mal. Si hubieras leido mas de 10 caracteres
* ya deberias tener problemas, no porque la cadena tenga muchas letras, sino
* por la escritura del stack. Es probable que tu programa sufra un buffer
* overflow. Por otro lado, declaraste 'str' y 'str2'... ¿para que? aqui
* se vuelve a usar el mismo 'registros[pos].nombre' en lugar de 'str', que
* actualmente apunta al mismo lugar.
*/
if(strlen(registros[pos].nombre) > MAX_LEN_STR_AGENDA) {
 puts("\nLo siento demasiadas letras");
 printf("El nombre %s", registros[pos].nombre);
 /* imprimo el numero de letras contenidas */
 /**
  * D4RIO: El tipo de retorno de strlen NO es int, esta
  * clase de errores pueden llevar a buffer overflows, el formato
  * para esto es %lu
  */
 printf(" tiene %lu letras ", strlen(registros[pos].nombre));
 break;
}
/**
* D4RIO:
* Esto esta muy mal por diversos motivos. Primero desde lo semantico,
* es redundante:
*
*   - NULL evalua a false porque es un cero (concretamente (void*)0)
*   - Cualquier otro valor evaluaria a true
*
* Por lo tanto comparar con NULL es irrelevante, podria haber sido
*
*   if ( isalpha(str) )
*
* Claro, eso si isalpha() aceptase cadenas por parametro, pero la funcion
* evalua un caracter, y debemos pasarlo casteado a (int), que es el tipo
* que recibe por parametro. Asi que deben armar una funcion que evalue
* isalpha() para cada caracter de la cadena, o decidirse por algo mas
* rapido y escribir una uds mismos, decidan, pero esto esta mal.
*/
if(isalpha(str) != NULL) {  /* verifico si es o no un tipo de dato alfabetico */
 puts("\nBien");
 estado = 1;
 break;
}
else {
 puts("\nEl nombre es incorrecto nada de caracteres o numeros raros");
 /**
  * aqui se supone que si lo que ingreso fue incorrecto
  * le digo que me lo elimine de la estructura
  */
 registros[pos].vacio = 0;
 estado = 0;
 break;
}
i++;
 }
 i = 0;
 while(str2) {  
if(strlen(registros[pos].apellido) > MAX_LEN_STR_AGENDA) {
 puts("\nLo siento demasiadas letras");
 printf("El apellido %s", registros[pos].apellido);
 /**
  * D4RIO: El tipo de retorno de strlen NO es int, esta
  * clase de errores pueden llevar a buffer overflows, el formato
  * para esto es %lu
  */
 printf(" tiene %lu letras",  strlen(registros[pos].apellido));
 break;
}
if(isalpha(str2) != NULL) {
 puts("\nBien");
 estado2 = 1;
 break;  
}    
else {
 puts("\nApellido es incorrecto   nada de numeros o caractes raros");
 registros[pos].vacio = 0;
 estado2 = 0;
 break;
}
i++;
 }
} while (estado != 1  ||  estado2 != 1);  
suma = x + y;
/* aqui valido y digo que se le pase el valor para poder ser registrado */
registros[pos].vacio = 1;
puts("\nEl registro a sido realizado\n");
return suma;
 }
}



/* adecuacion de la declaracion de funciones a lo usual */
void
consultar()
{
 int cont = 0;
 int codigo = 0;

 printf("\nIngresa el codigo: ");
 scanf("%d", &codigo);
 while(cont <= MAX_REG_AGENDA) {
/**
* igualo el codigo con el codigo de la estructura
*
* D4RIO: se dice 'asigno', no 'igualo'
*/
if(registros[cont].codigo == codigo) {
 /**
  * se supone que verifico si en determinada posicion vacio vale uno
  * y si es asi que me lo imprima
  *
  * D4RIO: no se supone, es
  */
 if(registros[cont].vacio == 1) {
printf("\nNombre: %s", registros[cont].nombre);
printf("\nApelldio: %s", registros[cont].apellido);
break;
 }
}
cont++;
/* si es mayor a diez significa que no lo encontro */
if(cont > MAX_REG_AGENDA)
 puts("\nCodigo no encontrado");
 }
}
   


/* adecuacion de la declaracion de funciones a lo usual */
int
verifica_pos()
{
 int cont = 0;
   
 while(cont <= MAX_REG_AGENDA) {
if(registros[cont].vacio == 0)
 return(cont);
cont++;
 }
 /* retorno -1 para comprobar que no este lleno */
 return -1;
}




void
desmarcar_pos()
{
 int cont;

 /**
  * no entiendo muy bien
  *
  * D4RIO: parece que 'vacio' es una marca, la pone en cero
  * para todos los registros
  */
 for(cont = 0; cont <= MAX_REG_AGENDA; cont++)
registros[cont].vacio = 0;
}



/* adecuacion de la declaracion de funciones a lo usual */
int
verifica_cod(int codigo)
{
 int cont = 0;
   
 while(cont <= MAX_REG_AGENDA) {
/**
* comparo el codigo y si es el mismo que me imprima
* que no se puede tener el mismo codigo
*/
if(registros[cont].codigo == codigo) {
 puts("\nLo siento no puedes tener el mismo codigo");
 return 0;
}
cont++;
 }
 /* retorno 1 para decirle que pueda continuar si es que no es el mismo */
 return 1;
}



/* adecuacion de la declaracion de funciones a lo usual */
int
excluir()
{
 int codigo;
 int cont = 0;
   
 printf("\nIngresa el codigo para ser eliminado: ");
 scanf("%d", &codigo);
 while(getchar() != '\n');
 while(cont <= MAX_REG_AGENDA) {
/* compara como arriba */
if(registros[cont].codigo == codigo)
 /**
  * verifico  que  el valor de la estrctura de determinada posicion
  * sea iguala  uno para eliminarlo con la linea sigueinte
  *
  * D4RIO: cuando mencionas 'el valor de la estructura',
  * es el valor de 'vacio'
  */
 if (registros[cont].vacio == 1) {
registros[cont].vacio = 0;
puts("\nEliminado correctamente");
break;
 }
cont++;
/**
* D4RIO: Esta parte se merece un premio a la falta de logica.
* La condicion del bucle era mientras cont sea menor o igual
* que la cantidad de registros de la agenda, eso significa que
* JAMAS entraria al bucle si esta condicion se fuera a cumplir
*/
if(cont > MAX_REG_AGENDA)
 puts("\nCodigo no encontrado");
 }
 return codigo;
}

Yo no entiendo cómo UNIX / UNIX-like es un subforo de GNU/Linux. Es un poco insultante. GNU no tiene nada que ver con UNIX, ni Linux con los kernels más tradicionales. Las categorías deberían ser:

Código [Seleccionar] Expandir


S.O. +
     +--> Windows
     +--> GNU
     +--> UNIX-like +
                    +--> OpenBSD / NetBSD
                    +--> FreeBSD
                    +--> Mac OS X


O quiza:

Código [Seleccionar] Expandir


S.O. +
     +--> Windows
     +--> GNU
     +--> BSD +
              +--> Mac OS X


Como sea, Mac es un UNIX hecho y derecho.

Probaste usando otro router? Uno que soporte otras especificaciones de WiFi?

Claro que sí se puede.

Si estás logueado, entonces busca el archivo con el hash del password en /var/db/dslocal/nodes/Default/users/*.plist. Luego usas john the ripper y obtienes el password.

Simple, a menos que el password sea muy complejo, lo cual le lleva a john un tiempo largo.