¿¿ cosas raras compilando -> fallo del g++ ??

Archivado
Hola, pues eso, tengo que hacer fibonacci recursivo DyV y ya lo tengo implementao, la cosa es que si lo compilo en windows va bien, consigo hasta fibonacci de 1200 y pico que ya es un numero bastante grande...y bien, PERO si compilo en linux a partir de 44 peta, vamos, overflow o lo que sea que salen numeros negativos y cosas asi. Si funciona al compilarlo en windows, tambien deberia hacerlo en linux no? los tipos de datos seran los mismos no?
Pero es que lo peor viene, cuando he metio para calcular la eficiencia, usando la función colck(), en windows si que captura, y pudes sacar el tiempo en segundos al dividirlo por clock_per_sec o como se escriba, me sale 40, 70, 30...y si lo dibidio, pues me sale 0'002 y cosas asi, pero en linux na, sale 0 y 0!!!

Puede ser del compilador que te to cagao? de linux ( [enfa] ) o alguna idea? :(
¿Has probado a depurar el programa? ¿Qué IDE estás usando?

PD: Intenta escribir un poco mejor, está claro que esto es un foro y tampoco hace falta que seamos todos académicos de la lengua, pero es más fácil responder si es más fácil leerte.

Saludos!
Seria bueno ver el codigo ...
flamel escribió:¿Has probado a depurar el programa? ¿Qué IDE estás usando?

¿ que es IDE ? [+risas] (es que yo no entiendo mucho de lenguajes tecnicos)

flamel escribió:PD: Intenta escribir un poco mejor, está claro que esto es un foro y tampoco hace falta que seamos todos académicos de la lengua, pero es más fácil responder si es más fácil leerte.

fallo mio! estoy intentando mejorar! [oki]

Sertinell escribió:Seria bueno ver el codigo ...

¿el de la función? ¿o en el que utilizo clock() ?

ah, y gracias por responder!
Es posible que sea culpa de como interpreta las cosas el compilador. Si en windows has utilizado Visual Studio no tiene porque comportarse igual.
elmenda escribió:¿ que es IDE ? [+risas] (es que yo no entiendo mucho de lenguajes tecnicos)

Jeje, no problem. IDE son las siglas en inglés para Entorno de Desarrollo Integrado, es decir, un programa como Visual Estudio o Eclipse que sirven para integrar las aplicaciones que se usan cuando programas: compilador, depurador, editor, etc...

Te lo digo por que usando algún IDE puedes depurar de forma más o menos sencilla el programa y encontrar muchos errores que suelen ser debidos a punteros mal manejados y cosas así... aunque no te puedo decir mucho más por que mis conocimientos de C++ son prácticamente nulos.

Si necesitas algún IDE te recomiendo Eclipse tanto para Windows como para Linux. Además es software libre.

fallo mio! estoy intentando mejorar! [oki]

No problem.

Lo del código también es importante. Pégalo en algúna página como esta http://p.caboo.se/ y luego pega el enlace que te genera la página aquí.

Saludos!
Eso, si lo pegas lo intento arreglar, que quiero picarme con algo y ahora estoy un tanto aburrido (hasta q me vaya a sobar). xD
Hola! perdón por la tardanza! en cuanto al entorno, en windows uso el dev c++, y en linux no se como se llama...g++ no? y eso, ya no es el algoritmo en si, es que cualquier cosa simplona, yo que se, por ejemplo

#include
using namespace std;
#include

int main(){
clock_t t_despues = clock();
double time;
time = (((double)(t_despues)))/CLOCKS_PER_SEC;
cout << time << " "<< t_despues << endl;
system ("pause");
}


si compilo en windows me salen cosas, y en linux SIEMPRE 0 0. Tiene que ser cosas del compilador no? si no, nunca funcionaría nada no?
Este simple programa, que lo único que hace es perder el tiempo, no devuelve 0 0:

#include <iostream>
#include <vector>
#include <ctime>

int main(int argc, char *argv[])
{
   for (int i(0), i_end(100) ; i != i_end ; ++i)
   {
      std::vector<int> v(10000, i);
      for (std::vector<int>::iterator it(v.begin()), it_end(v.end())
            ; it != it_end ; ++it)
         *it = *it * i;
   }
    clock_t t_despues(clock());
    double time((double)t_despues / CLOCKS_PER_SEC);
    std::cout << time << " " << t_despues << std::endl;
    return EXIT_FAILURE;
}


El problema me da a mi que no está en el compilador... mira bien tu código y las funciones que estás usando. Si windows te da algo distinto de 0 0 en ESE código, es que es imbécil.

- ferdy
Ferdy escribió:El problema me da a mi que no está en el compilador... mira bien tu código y las funciones que estás usando. Si windows te da algo distinto de 0 0 en ESE código, es que es imbécil.
- ferdy


como? en cual codigo? en el que tu has escrito? a ver, esto no deberia salir algo distinto de cero? (me refiero a (long)(t_despues - t_antes)) / (CLOCKS_PER_SEC*veces))
int main (){

int n;
long fibo, veces = 999999999;
cout << "mete n" << endl;
cin >> n;
clock_t t_antes = clock();
for (int i = 0; i < veces; i++){
fibo = dyv_fibonacci (n);
}
clock_t t_despues = clock();
if (fibo == -1)
cout << "mete numero positivo" << endl;
else{
cout << n << "  " << ((long)(t_despues - t_antes)) / (CLOCKS_PER_SEC*veces)<< endl;
cout << fibo << endl;
}
system("pause");
}
elmenda, acabo de probar tu código y no me da 0 :)

Me da la impresión de que tu máquina debe ser muy rápida.
Tu no quieres usar clock, mira la función gettimeofday.

- ferdy
kamen escribió:Me da la impresión de que tu máquina debe ser muy rápida.

xDDDD eso quisiera yo!! si esto es una patata!!

kamen escribió:elmenda, acabo de probar tu código y no me da 0 :)


a eso me refiero, que a mi no me da 0, PERO si compilo en linux si.

Ferdy escribió:Tu no quieres usar clock, mira la función gettimeofday.


hombre, yo siempre he usado clock, de echo, si compilo con el dev-c++ si que funciona. Yo lo unico que quiero es ver el tiempo (o el tic ese que creo que se dice ^^) de procesador antes de la llamada, el de despues, y calcular cuanto tiempo ha pasado, para ver la eficiencia del algoritmo en funcion de las entradas, la función gettimeofday que hace? decir la hora del dia o que? ein?
La prueba está hecha en una debian sobre un duron 700@800.
kamen escribió:La prueba está hecha en una debian sobre un duron 700@800.


eso que significa? yo es que digo, que el problema puede que sea del g++ no? no de linux vaya, no hay otro compilador para linux?
No, el problema no es del compilador tampoco. El problema está en lo que intentas medir. Prueba a restar gettimeofday antes y después del cálculo.

- ferdy
[semiofftopic] muy cachondo lo del system("pause"); y muy multiplataforma y estandar xDDD [/semiofftopic]
En la prueba que hice yo usé el g++.

Prueba esto a ver si te funciona.

#include
#include

void wait ( int segundos)
{
clock_t endw;
endw = clock () + seconds * CLOCKS_PER_SEC ;
while (clock() < endw) {}
}

int main ()
{
int n;
printf ("Cuenta atras.\n");
for (n=10; n>0; n--)
{
printf ("%d\n",n);
wait (1);
}
printf ("BOOM!!!\n");
return 0;
}


Si lo que al final quieres ver es cuanto tiempo ha tardado el programa en hacer las operaciones es mejor que uses el gettimeofday. Si lo que quieres ver son los ciclos de CPU entre una llamada y otra sigue usando clock.
si ya no creo que sea cosa de usar ettimeofday o clock, es que lo raro es que me de 0 0 y a ti por ejemplo no (kamen) y lo que me pasa con el rango de numeros... [reojillo] , ¿nadie tiene idea de aa que puede deberse? [comor?]
elmenda escribió:Hola, pues eso, tengo que hacer fibonacci recursivo DyV y ya lo tengo implementao, la cosa es que si lo compilo en windows va bien, consigo hasta fibonacci de 1200 y pico que ya es un numero bastante grande...y bien, PERO si compilo en linux a partir de 44 peta, vamos, overflow o lo que sea que salen numeros negativos y cosas asi. Si funciona al compilarlo en windows, tambien deberia hacerlo en linux no? los tipos de datos seran los mismos no?
Pero es que lo peor viene, cuando he metio para calcular la eficiencia, usando la función colck(), en windows si que captura, y pudes sacar el tiempo en segundos al dividirlo por clock_per_sec o como se escriba, me sale 40, 70, 30...y si lo dibidio, pues me sale 0'002 y cosas asi, pero en linux na, sale 0 y 0!!!

Puede ser del compilador que te to cagao? de linux ( [enfa] ) o alguna idea? :(


No viene mucho al cuento pero... sabes como calcular la eficiencia en eclipse para aplicaciones java? Tambien estoy liado con dyv, pero con un problema de par mas cercano en 3 dimensiones.

Salu2
mira a ver si esto también te da 0.

#include <iostream>
#include <ctime>

using std::cout;
using std::endl;

long int fibRec(size_t x);

int main() {
   for(size_t i = 1; i < 40; ++i) {
      clock_t t0 = clock();
      long int res = fibRec(i);
      clock_t t1 = clock();
      cout << res << '\t' << (double)(t1-t0)/CLOCKS_PER_SEC << endl;
   }
}

long int fibRec(size_t x) {
   if(x == 1 || x == 2) return 1;
   else return (fibRec(x-1) + fibRec(x-2));
}


una pregunta en general, gettimeofday va en windows?
ahora mismo lo miro, pero juraria que si, que da 0 sueguro...digo yo, a ver si mi g++ es tan "tonto" que no tiene la libreria ctime...eso pudiera ser?

4eVaH si ya tienes el algoritmo, calcular la eficiencia empirica ta tirao, es solo mirar el tiempo antes y despues de llamar a la función, y mirar como crecen los resultados en funcion del tamaño de las entradas, vamos, sacas los datos tipo: n t(n) y el xmgrace te pinta la grafiquita y todo.
he cambiado el codigo mientras escribías... he dicho buah, para probar una tontería mejor pruebo el ejercicio de verdad [sonrisa]
jiji ya copiao el nuevo, aqui en windows si que rula bien, voy a reinciar el potatoe este a linux a ver...pero me temo que seguro que sale 0...ahora te digo!

Que estaba viendo a dios! ostiaaa pues si que funciona!! no sale siempre 0!! y la unica diferencia es que asignas
const double pps = CLOCKS_PER_SEC;

en lugar de usar CLOCKS_PER_SEC directamente no?
y usar el using namespace std; no tendrá nada que ver no? xq esa es la otra diferencia que veo...a ver si alguien me aclara este misterio sin resolver!! [360º]

vale! cuando lo has editao ya lo has quitao, asi no lo probao, no se si funcionará o es ese el kit de la cuestion! :P
lo de pps no es porque lo he vuelto a modificar y ahora uso la macro directamente xDD

y lo de std sólo es para usar cout y endl.

en tu código veo esto:

cout << n << "  " << ((long)(t_despues - t_antes)) / (CLOCKS_PER_SEC*veces)<< endl;


estás multiplicando clocks_per_sec por veces? como veces es muy grande (9999999), divides por algo muy grande, y entonces el resultado de la división te da algo muy chico. y como haces un casting a long, que es lo mismo que long int, en vez de a double, no salen decimales por lo que el resultado es 0. Lo mismo es eso...
:O aaaaaahm y como hacer un casting a algo que pueda tener decimales? es que no tiene mucho sentido, si el tiempo va a ser 0'000lo que sea, que sea un entero no? en vez de poner (long) poner (double) y yasta no? Lo de hacer CLOCKS_PER_SEC*veces es xq como supuestamente eso va follao y pues lo ejecuto veces (muchas) y para que luego el tiempo que salga sea el que saldría al ejecutarlo solo una vez, no se si me explico, el tuyo por ejemplo, pues saca el tiempo que tarda en hacer eso 40 veces no una...y lo de editar, cuando lo copiao todavia no habias editado y lo compilao con pps!! [jaja]
Para hacer esa medida indirecta creo que es mejor que hagas un promedio de veces ejecuciones, así cada medida es independiente de las demás por lo que el resultado final es más fiable. Iría acumulando el tiempo de cada ejecución y luego lo dividiría entre veces.

int main() {
   for(size_t i = 1; i < 40; ++i) {
      double acumulado = 0.0;
      const size_t veces = 50; // Para cada i, calcula la media de 50 ejecuciones
      for(size_t j = 0; j < veces; ++j) {
         clock_t t0 = clock();
         long int res = fibRec(i);
         clock_t t1 = clock();
         acumulado += (double)(t1-t0)/CLOCKS_PER_SEC;
      }
      cout << acumulado/veces << endl;
   }
}


cómo has hecho la función de dyv de fibonacci? ya me da curiosidad :-P
en verdad lo que tu dices es lo mismo que lo que yo quiero hacer no? ver lo que tarda en hacerlo n veces, y luego dividirlo por eso y por las veces que se ha repetido...vamos, yo siempre lo e echo asi y ha funcionado...Pero es que es mosqueante es eso que me pasa, de que aqui (en xp) me lo haga hasta del 1200 y pico, y en linux a partir del 43 pete.... [mamaaaaa]

El algoritmo es una chominá, para el fibonacci de n se sabes que si elevas a n la matriz a, siendo a=[0,1,1,1]:

|0 1|^n
|1 1|

pues el fibonacci de n es el a12 y el a21, y con eso, pues una formulita que segun si es par, fibo (n) = fibo (n/2) * fibo (n/2), o no, fibo (n) = fibo (n-1/2) * fibo (n-1/2) * a. Mas o menos, una cosa asi...con lo facil que es calcularlo como toda la vida de dios!! [tomaaa]
Es imposible que el dev-c++ te haga eso hasta el 1200 porque se sale del rango. Si tu ordenador es de 32 bits el número más grande que puedes tener es 111111...1: 32 unos en binario, o sea, 4.294.967.295 en decimal (en limits.h aparece esta linea: #define ULONG_MAX 0xffffffffUL). Eso habría que hacerlo con el mathematica o algún programa de ésos, que usa números de longitud arbitraria. Para hacerlo en el dev-c++ tendrías que crearte un tipo entero de longitud arbitraria usando un vector o lo que sea.

Revisa que el resultado que te da es el correcto del 47 en adelante, el 48 ya es más grande que el límite.
ostia, pues es verdad! pues te lo juro que no se como, metia hasta 1000 y pico y salia "bien" (vamos que no salia negativo) [+risas]
bueno, pues entonces, un problemilla menos!! es normal que pete a partir del 44 no? ^^ a ver si mañana soluciono lo del clock()

Gracias! [tadoramo]
Mira, el mathematica trae la función Fibonacci ya... esto es lo que sale:

Imagen
30 respuestas
Archivado
Volver a Software libre