Mensajes

[C99]

hola sobre el tema de los números grandes, estaba buscando para que sirven los int8_t int16_t etc, y salio un tema interesante que lo conseguí de casualidad, dependiendo del nivel de precisión podrías usar algo llamado "punto fijo"...no se si sirva, pero para leerlo y ver si te sirve...acá una cosa que encontré referido al tema

Por lo que tengo entendido, no logras más allá de los veinte dígito, en enteros, de los que obtendrías con un long long int. Otra cosa es que las nuevas librerías del C99 permiten un mayor control en la declaración del tipo de enteros en cuanto a su precisión/número de dígitos.

Saluditos!. .... ..

[Porfa]

Porfa, que fulminen el post anterior y le bloqueen la dirección ya que no desaprovecha ocasión para meternos su estúpida propaganda,

Saluditos! .... ..

P.D: Gracias" a los de arriba" por la prontitud en la reacción. Aclaro que cuando me refiero al post anterior era a uno de propaganda de teléfonos que ya han borrado.

[e^x]

Hola,
tengo que calcular el valor de e^x con la serie 1+x+((x^2)/2!)+((x^n)/n!)

1- No estoy seguro si he definido bien las variables
2- Para numeros muy grandes el resultado es falso, se arroja un numero negativo, leí en otro tema que se debe definir una funcion que permita numeros muy grandes (a la hora de calcular el factorial) porque la compilacion tiene un limite.

¿Se puede definir una variable mayor a long long?

* Aparentemente as tienes bien definidas.

* Es el gran problema de C/C++, como el número entero tenga del orden de 20 cifras cruje, no da para más, sino prueba con 100 y 100 y veras.

* Tendría que repasar las nuevas librerías del estandar C99.

En todo caso el código que utilizas cojea en algunas cosas.

*  Por ejemplo, cuando se trata de calcular e^x el número de términos ha de ser algo secundario ya que lo que en realidad interesa es calcularlo con una determinada precisión, y es esa precisión la que determina automáticamente el número de términos a tomar. En tu caso podrías entrar 3^10 tomando 10 sumandos y no tendrías una referencia de la precisión de ese cálculo.

* Otro detalle es la ineficiencia de la forma de calcular e^x, en el sentido que utilizas pow, que en si mismo no está mal, y sobre todo en la forma de calcular el factorial, culpable en números grandes- el factorial crece muy rápidamente- con la combinación de pow. Ambos juntos hace que a poco que crezcan los números y el número de  términos de la serie a tomar obtengas resultados fuera del alcance o capacidades de C/C++.

* Un mejor método es tener en cuenta que e se calcula, utilizando el desarrollo en serie, de forma que cada nuevo sumando es el anterior multiplicado por un factor :x/n. Con este método alternativo no tienes ni que usar pow ni hacer el cálculo de factoriales previamente.

* Otra cosa a tener en cuenta es introducir una condición de precisión que determine de forma automática el número de sumandos a tomar.

* Y como último comentario a tu código, manejas pocos decimales para hacer cálculos de esta índole.

* También sería interesante comparar la diferencia entre el valor calculado con el valor exacto, entendiendo por éste el valor que de e^x daría la función e^x de la librería de math, que supongo hace uso de un algoritmo parecido al que te comento y paso a darte como variante del tuyo, y como muestra me da estas salidas:

Código (cpp) [Seleccionar] Expandir

Teclea el valor de x: 100
Valor estimado: 2.688117141816136e+043
Valor exacto: 2.688117141816136e+043.
Error cometido: -1.525664384353662e+027 .
Numero de terminos utilizados: 205

Teclea el valor de x: 500
Valor estimado: 1.403592217852838e+217
Valor exacto: 1.403592217852838e+217.
Error cometido: -6.745532683619974e+200 .
Numero de terminos utilizados: 716

Teclea el valor de x: 709
Valor estimado: 8.218407461554972e+307
Valor exacto: 8.218407461554972e+307.
Error cometido: -1.900336232223e+291 .
Numero de terminos utilizados: 964

Y el código para ello, que no se diga que no compartimos secretillos:

Código (cpp) [Seleccionar] Expandir


/* e^x
*la condición de finalización de las iteraciones: para este ejercicio
utilizamos un bucle while y dos series (con los nombres serie y
serie2  ) cuya diferencia mutua esta en un término,es decir,
serie2 tiene un término más que serie1 . La razón de esta forma de
calcular la serie la encontramos una vez más en la capacidad de almacenamiento de las variables tipo double : la fracción que
calculamos y que añadimos a la serie es cada  vez más pequeña
y, por tanto, la diferencia entre las dos series  también. Llega
un momento en el que las cifras significativas que   puede almacenar
la variable no son apreciables y la fracción que  sumamos no
representa cambio en las variables: en ese momento las  series
toman el mismo valor, se igualan y, por tanto, se termina  la
ejecución del bucle*/

#include <stdio.h>
#include <math.h>
int main(void)
{
    double x, serie1, serie2, frac;
    int i;
    while (1)
    {
        printf("Teclea el valor de x: ");
        scanf("%lf", &x);
        serie1=1.0;
        frac=x;
        serie2=serie1+frac;
        i=2;
        while (serie1!=serie2)
           {
                serie1=serie2;
                frac=frac*x/i++;
                serie2=serie1+frac;
           }
       printf("Valor estimado: %1.16g\n", serie2);
       printf("Valor exacto: %1.16g.\n", exp(x));
       printf("Error cometido: %1.16g .\n", exp(x)-serie2);
       printf("Numero de terminos utilizados: %d\n\n", i);
    }

   return 0;
}


* Existe otra variante para que el usuario indique la precisión con que quiere calcular e^x, pero eso te lo dejo como un simple ejercicio a partir del código anterior.

Saluditos!. ... ..

[constructiva]

Por lo visto no lo pude explicar bien, déjame intentarlo de nuevo.
.................................................
Espero todo esto se tome como una critica constructiva.

Un saludo

Quien se explico mal debí ser yo. El código que planteé era para la cadena concreta que había planteado mcKicrO, no para un caso más general. De todas formas acepto con toda humildad la observación.

Y respecto de lo segundo, que te voy a decir. Todo lo que viene de ti lo meto en un fichero denominado consejos_rir, y no es coña marinera. Alucino con tu control del/los lenguajes C/C++. Pienso que es una suerte tener a alguien de tu preparación aconsejándonos a los noveles como yo.

Un fuerte saludo amigo rir!. .....

[Saluditos!. .... ..]

Sí, son muy parecidas. La mayor diferencia es el rendimiento de las operaciones:
................................................
Básicamente, los vectores ganan en acceso aleatorio y las listas ganan en inserción/borrado aleatorio.

Por lo que veo verifican las mismas características que existen en C entre los arrays y las listas, lo cual me confirma en la idea de que la clase lista en C++ es una implementación de todas aquellas funciones/operaciones que en C hay que hacer "a mano" a través de punteros. Sin duda una comodidad a favor de C++ sobre todo porque yo aún me lío con el uso de los puteros en las listas.

Gracias otra vez por  la información tan clara y puntual que me ofreces.

Saluditos!. .... ..

[Saluditos campeón !... ...]

Bueno ya que estoy, te digo más cosas de las listas.
.....................................

Gracias nuevamente, dedicaré unos días a empollarme el tema, parece interesante. Aunque visto a bote pronto es casi como la clase vector, de entrada parecen muy semejantes. Pero, en fin,supongo que según profundice en el tema veré mejor las diferencias y bondades de cada método.

Saluditos campeón !... ...

[Saluditos y gracia nuevamente!. .... ..]

¡De nada! Te dejo la referencia:
http://www.cplusplus.com/reference/list/list/

Pero el uso es idéntico a los vectores, solo hay que sustituir vector -> list y hacer el include:

Código (cpp) [Seleccionar] Expandir

#include <list>

Como no tienes el operador []. Para recorrer una lista tienes que usar un iterador:

Código (cpp) [Seleccionar] Expandir

list<int>MiLista;

// Relleno la lista

for (int i = 0; i < 100;i++)
  MiLista.push_back(i);

// La muestro por pantalla

for (list<int>::iterator it = MiLista.begin(); it != MiLista.end();it++)
{
  cout<<*it<<endl;
}

Thanks, muchas thanks, creía que iba ser un tromento como las listas de C, todas llenas de punetros que al final no sabes ni adonde apunta los punteros y las flechas.  . Ahora me meteré de lleno con ese tema, me has quitado el miedo a otro rollo batatero.

Saluditos y gracia nuevamente!. .... ..

[coloquen el ejemplo de un código en C de un menú en el que con los cursores se resalten la opcion (El clásico video invertido)]

Por favor, coloquen el ejemplo de un código en C de un menú en el que con los cursores se resalten la opcion (El clásico video invertido) y al presionar Enter se seleccione la opción señalada, no me refiero a los menús en el que la opción se seleccione pulsando el número o letra indicada.

La verdad es que me lo he tomado como todo un reto y al final salió, aunque es sólo un esbozo de algo que haré más depurado con un pelín más de tiempo, pero para que vayas viendo algo. Eso sí, haciendo uso  de las API de windows y con color en el contraste y en la opción seleccionada. Para más información a este respecto ver el tema de gama de colores. Espero te sea útil:

Código (cpp) [Seleccionar] Expandir

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

void contraste (int abajo);

int main ()
{
   int arriba=1,abajo=1;
   puts ("Menu");
   puts ("1. Entrar datos");
   puts ("2. Leer datos");
   puts ("3. Borrrar datos");
   gotoxy (0,1);
   while (1)
   {
       contraste ( abajo);
       if (abajo>3 || abajo<1)
           {
               gotoxy (0,1);
               abajo=1;
           }

       else if (GetAsyncKeyState(VK_DOWN))
           {
               contraste ( abajo);
               gotoxy (0,abajo+1);

               abajo++;
               Sleep(100);
           }
       else if (GetAsyncKeyState(VK_UP))
           {
               contraste ( abajo);
               gotoxy (0,abajo-1);
               contraste ( abajo);
               abajo--;
               Sleep(100);
           }
       else  if (GetAsyncKeyState(VK_RETURN))
               {
                   system ("cls");
                   if (abajo==1)
                       {
                           color (30);
                           puts("Hago esto si abajo=1");
                           color (7);
                           break;
                       }
                   else if (abajo==2)
                       {
                           color (62);
                           puts("Hago esto si abajo=2");
                           color (7);
                           break;

                       }
                   else
                       {
                            color (181);
                            puts("Hago esto si abajo=3");
                            color (7);
                            break;
                       }

                   Sleep(100);
               }
   }
   system ("pause");
   return 0;
}

int gotoxy(int x, int y)
{
  COORD coord;
  HANDLE h_stdout;
  coord.X = x;
  coord.Y = y;
  if ((h_stdout = GetStdHandle(STD_OUTPUT_HANDLE)) == INVALID_HANDLE_VALUE)
     return 0;
  if (SetConsoleCursorPosition(h_stdout, coord) == 0)
     return 0;
  return 1;
}
int color (int n)
{
       SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}

void contraste (int abajo)
{

       if (abajo ==1)
       {
           color (7);
           gotoxy (0,0);
           puts ("Menu");
           color (112);
           puts ("1. Entrar datos");
           color (7);
           puts ("2. Leer datos");
           puts ("3. Borrrar datos");
           gotoxy (0,abajo);
           Sleep(100);
       }
       else if (abajo ==2)
       {
           //color (112);
           gotoxy (0,0);
           color (7);
           puts ("Menu");
           puts ("1. Entrar datos");
           color (112);
           puts ("2. Leer datos");
           color (7);
           puts ("3. Borrrar datos");
           color (7);
           gotoxy (0,abajo);
           Sleep(100);
       }
      else  if (abajo ==3)
       {
           //color (112);
           gotoxy (0,0);
           color (7);
           puts ("Menu");
           puts ("1. Entrar datos");
           puts ("2. Leer datos");
           color (112);
           puts ("3. Borrrar datos");
           color (7);
           gotoxy (0,abajo);
           Sleep(100);
       }
}


Saluditos!. ... ..

[las mismas]

C++ incluye también una clase lista que ofrece las mismas funciones que la clase vector

Bueno miento, el operador [] no está pero tampoco hace falta porque recorro el contenedor entero, no necesito acceder a posiciones aleatorias.

Gracias por la información, en C++ ando escasito de conocimiento  aún, pero todo se andará.

Y como habrás notado, los códigos que realmente me atraen son especialmente los numéricos, supongo que por deformación profesional. De ahí que esté estirando el tema de la matriz de 10x10 como un chicle, le estoy sacando el jugo en forma de game a algo que inicialmente era pura cálculo. Digo esto último por la ingeniosa forma que se me ocurrió para generar los aleatorios entre uno y mil sin que se repitieran.

Saluditos!. ....Y como buen Leo me despido a lo grande:

[Saluditos .... Miguel!. .....]

Un fuerte saludo de éste canarión y gracias por contribuir a hacer esto menos impersonal de lo que ya es. 

Saluditos .... Miguel!. .....