Frases

...Algunas cosas las hace el hombre, y otras el hambre...

Profesor Web

Fujitsu Venus: El procesador más rápido del mundo

El procesador en cuestión fue bautizado como "Venus", un nombre que puede no ser muy original pero es mucho más agradable que el SPARC64 VIIIfx que tuvo al principio. La presentación fue llevada a cabo en el "Fujitsu Forum 2009", y la única imagen que ha trascendido los medios nos muestra a un procesador significativamente más grande de lo que hemos vista hasta ahora. Sin embargo, el tamaño físico no es lo único grande en este procesador. Su capacidad, de acuerdo a sus desarrolladores, puede alcanzar un pico máximo de 128 Gigaflops, aproximadamente dos veces y medio el poder de procesamiento del mejor exponente de Intel en existencia


.
Ahora, nosotros los usuarios tal vez estemos acostumbrados a ver los logros de Fujitsu a través de otros productos y componentes, como son discos duros y ordenadores portátiles, pero lo cierto es que Fujitsu ha demostrado tener una gran experiencia en la fabricación de procesadores y ordeandores de alto poder. Es más, su súperordenador "Numerical Wind Tunnel" fue primero en la lista de los 500 ordenadores más poderosos del mundo entre 1993 y 1996, lo cual no es poco.

El procesador ha sido fabricado con tecnología de 45 nm, y cuenta con un total de ocho núcleos. Como si eso fuera poco, Fujitsu ha declarado que Venus requiere solamente un tercio de la energía que necesita el mejor chip de Intel. Hasta el momento se desconocen otros detalles como la cantidad de caché y las propiedades de su zócalo, pero pocas dudas quedan de que Venus es el procesador más poderoso del planeta. Aún no se tiene una idea específica de las aplicaciones prácticas del procesador (y podría demandar varios años determinarlas), sin embargo se especula que Venus podría tener un uso intensivo en campos como la medicina, en el desarrollo de nuevas drogas. Además, un detalle no menos importante: Fujitsu ha dicho que la posibilidad de adaptar esta tecnología para crear procesadores de consumo general, "no ha sido descartada".

Calculadora números complejos

Este, no es más que una calculadora. Lo interesante, es que se trata de números complejos, como 10+5i, por ejemplo.. con un menú de opciones.

#include 'cstdlib'
#include 'iostream'
#include 'stdio.h'
#include 'math.h'

struct complejo tpolar (struct complejo);
struct complejo trectangular(struct complejo);
struct complejo bsuma (struct complejo, struct complejo);
struct complejo fpotencia (struct complejo, float);
struct complejo fproducto (struct complejo, struct complejo);
struct complejo { float a, b; };
struct complejo fdivision (struct complejo, struct complejo);

int main(void)
{
int opcion;
printf ("\t\t\t\tNUMEROS COMPLEJOS\n\n");
printf ("Seleccione la operacion que quiera realizar\n\n");
printf ("1-Pasaje de forma rectangular a forma polar\n");
printf ("2-Pasaje de forma polar a forma rectangular\n");
printf ("3-Sumar dos numeros complejos. Nota: Ingrese los valores en forma rectangular\n");
printf ("4-Multiplicar dos numeros complejos. Nota: Ingrese los valores en forma polar\n");
printf ("5-Dividir dos numeros complejos. Nota: Ingrese los valores en forma polar\n");
printf ("6-Potenciacion. Nota: Ingrese los valores en forma polar\n\n");
printf ("Nota: La fase de los numero complejos debera ser ingresada en radianes y sera devuelta tambien en radianes \n\n");
scanf ("%d", &opcion);
switch (opcion)
{
case 1 :
printf ("\n1-PASAJE DE FORMA RECTANGULAR A FORMA POLAR\n\n");
struct complejo fpolar, frectangular;
printf ("Ingrese la parte real del numero complejo:");
scanf ("%f", &frectangular.a);
printf ("Ingrese la parte imaginaria de numero complejo:");
scanf ("%f", &frectangular.b);
fpolar = tpolar (frectangular);
printf ("\nEl modulo del numero complejo es =%f\n", fpolar.a);
printf ("La fase del numero complejo es =%f\n\n", fpolar.b);
system("PAUSE");
return EXIT_SUCCESS;

break ;

case 2 :
printf ("\n2-PASAJE DE FORMA POLAR A FORMA RECTANGULAR\n\n");
struct complejo frec, fpol;
printf ("Ingrese el modulo de numero complejo:");
scanf ("%f", &fpol.a);
printf ("Ingrese la fase de numero complejo:");
scanf ("%f", &fpol.b);
frec = trectangular (fpol);
printf ("\nLa parte imaginaria del numero complejo es =%f\n", frec.a);
printf ("La parte real del numero complejo es =%f\n\n", frec.b);
system("PAUSE");
return EXIT_SUCCESS;

break ;

case 3 :
printf ("\n3-SUMAR DOS NUMEROS COMPLEJOS\n\n");
struct complejo z2p,z1p, csuma;
printf ("Ingrese la parte real del primer numero complejo:");
scanf ("%f", &z1p.a);
printf ("Ingrese la parte imaginaria del primer numero complejo:");
scanf ("%f", &z1p.b);
printf ("\nIngrese la parte real del segundo numero complejo:");
scanf ("%f", &z2p.a);
printf ("Ingrese la parte imaginaria del segundo numero complejo:");
scanf ("%f", &z2p.b);
csuma = bsuma (z1p, z2p);
printf ("\nEl resultado es= %f +j%f\n\n", csuma.a,csuma.b);
system("PAUSE");
return EXIT_SUCCESS;

break ;

case 4 :
printf ("\n4-MULTIPLICAR DOS NUMEROS COMPLEJOS\n\n");
struct complejo z2pa,z1pa, producto;
printf ("Ingrese el modulo del primer numero complejo:");
scanf ("%f", &z1pa.a);
printf ("Ingrese la fase del primer numero complejo:");
scanf ("%f", &z1pa.b);
printf ("\nIngrese el modulo del segundo numero complejo:");
scanf ("%f", &z2pa.a);
printf ("Ingrese la fase del segundo numero complejo:");
scanf ("%f", &z2pa.b);
producto = fproducto (z1pa, z2pa);
printf ("\nEl resultado del producto es= Modulo= %f Fase=%f\n\n", producto.a,producto.b);
system("PAUSE");
return EXIT_SUCCESS;

break ;

case 5 :
printf ("\n5-DIVIDIR DOS NUMEROS COMPLEJOS\n\n");
struct complejo z2pb,z1pb, division;
printf ("Ingrese el modulo del primer numero complejo:");
scanf ("%f", &z1pb.a);
printf ("Ingrese la fase del primer numero complejo:");
scanf ("%f", &z1pb.b);
printf ("\nIngrese el modulo del segundo numero complejo:");
scanf ("%f", &z2pb.a);
printf ("Ingrese la fase del segundo numero complejo:");
scanf ("%f", &z2pb.b);
division = fdivision (z1pb, z2pb);
printf ("\nEl resultado de la division es= Modulo= %f Fase=%f\n\n", division.a,division.b);
system("PAUSE");
return EXIT_SUCCESS;

break ;

case 6 :
printf ("\n6-POTENCIACION\n\n");
struct complejo z1pc, potencia;
float exponencial;
printf ("Ingrese el modulo del numero complejo:");
scanf ("%f", &z1pc.a);
printf ("Ingrese la fase del primer numero complejo:");
scanf ("%f", &z1pc.b);
printf ("\nIngrese el exponencial:");
scanf ("%f", &exponencial);
potencia = fpotencia (z1pc, exponencial);
printf ("\nEl resultado de la operacion es= Modulo= %f Fase=%f\n\n", potencia.a,potencia.b);
system("PAUSE");
return EXIT_SUCCESS;

break ;

default : printf ("\nNo corresponde a ninguna opcion dada\n\n");

}

system("PAUSE");
return EXIT_SUCCESS;

}
struct complejo tpolar (struct complejo z)

{
float g,h,s,d;
struct complejo w;
g= pow (z.a,2);
h= pow (z.b,2);
s=g+h;
w.a = sqrt (s);
d=z.a/z.b;
w.b= atan (d);

return (w);

}
struct complejo trectangular (struct complejo z)

{
float c,d;
struct complejo w;
c = cos (z.b);
w.a = c * z.a;
d = sin(z.b);
w.b = d * z.a;
return (w);

}
struct complejo bsuma (struct complejo x, struct complejo y)

{
struct complejo w;
w.a= x.a + y.a;
w.b= x.b + y.b;
return (w);
}
struct complejo fproducto (struct complejo x, struct complejo y)

{
struct complejo w;
w.a = x.a * y.a;
w.b = x.b + y.b;
return (w);
}
struct complejo fdivision (struct complejo x, struct complejo y)

{
struct complejo w;
w.a = x.a / y.a;
w.b = x.b - y.b;
return (w);
}
struct complejo fpotencia (struct complejo x, float y)

{
struct complejo w;
w.a = pow (x.a, y);
w.b = x.b * y;
return (w);
}

Par, Impar, Cero

Este código lo que realiza, es detectar, si el número introducido por pantalla, es par, impar o cero. Lo presenta en forma de un byte, utilizando los bits, como flags para indicar el tipo de número.

#include
#include
#include



int main(void)
{
int numero, paridad,alu,peso;
char cero, positividad;
printf("Ingrese un numero entero:");
scanf("%d",&numero);
if (numero==0)
{
cero=(char)0X2;//Obtiene cero=0x4 o no cero=0x0.
}
else
{
paridad=(char)numero&1; //Obtiene paridad par=0x0, impar=0x1.
if(numero>=0)
{
positividad=(char)0;//Obtiene positivo=0x0.
}
else
{
positividad=(char)0X4;//Obtiene negativo=0x10.
}
}
alu=cero+positividad+paridad;//Junta la información en un byte para la alu.
for (peso=128;peso!=0;peso>>=1)//Lo traduce a binario.
{
if (peso<=alu)//pregunta por el orden de pesos de los caracteres.
{
printf("1");//imprime un 1 si el peso corresponde.
alu=alu-peso;//disminuye el peso para la próxima evaluación.
}
else
{
printf("0");//si el 1 no corresponde rellena con 0.
}
}
printf("\n");
printf("1er bit: par=0 impar=1\n");
printf("2do bit cero: v=1 f=0\n");
printf("3er bit: 0>=0 0<=1\n");
printf("\n");

system("PAUSE");
return EXIT_SUCCESS;
}
//1er bit: par=0 impar=1
//2do bit cero: v=1 f=0
//3er bit: 0>=0 0<=1

Frases

...La palabra con sangre, entra...

Profesor Análisis Matemático II

Descomponer un número en factores primos

Como sabemos, todos los números se pueden descomponer en una sucesión de números primos, y este programa hace eso. Recordamos que los números primos son aquellos que solo se puede dividir por si mismo, dando como resultado un número entero.

#include
#include

int main(void)
{
int cont,numero;
printf("Ingrese un numero entero para descomponer en factores primos:");
scanf("%d",&numero);
if (numero<0) //valida que el número ingresado no sea negativo.
{
printf("%d no es valido.\n",numero);
}
if (numero==1) //arregla el detalle de que todos los números son divisibles por 1
{
printf("1 es primo.\n");
}
else
{

while (numero!=1)//Cuando el resultado es 1 termina de descomponer
{
for (cont=2;cont<=numero;cont+=1)//realiza la división por todos los números menores
{
if (numero%cont==0)//Si una división tiene resto cero imprime
{
printf("%d\t|%d\n",numero,cont);
numero=numero/cont;//Cambia por el resultado de la división de resto cero
break;
}
}
}
printf("%d\t|\n",numero);
}
system("PAUSE");
return EXIT_SUCCESS;
}

Racional a fracción

En este caso, el programa se encarga, de devolver en pantalla, un número expresado en forma de fracción, el cual se introduce previamente en forma racional.

#include
#include
#include

int main(void)
{
float racional,Y;
int decimales,denominador,numerador,mult,densimp,numsimp,Z,X;

denominador=1;
printf("Ingrese un numero racional:");//Pide racional.
scanf("%f",&racional);
for(decimales=-1,Z=1;Y!=X;decimales+=1,Z*=10)//Obtiene cantidad de decimales.
{
Y=(racional*Z);
X=((int)Y);
}
for (mult=1;mult<=decimales;mult++,denominador*=10)//Multiplica por 10 como tantos decimales tenga.
{
}
numerador=(int)(racional*denominador);//Obtiene el numerador multiplicado.
printf("%f = %d\/%d",racional,numerador,denominador);//Fracción del racional.
while (numerador%2==0 && denominador%2==0)//Simplifica por 2.
{
numsimp=(int)(numerador/2);
densimp=(int)(denominador/2);
numerador=numsimp;
denominador=densimp;
}
while (numerador%5==0 && denominador%5==0)//Simplifica por 5.
{
numsimp=(int)(numerador/5);
densimp=(int)(denominador/5);
numerador=numsimp;
denominador=densimp;
}
printf("= %d\/%d\n",numerador,denominador);//Fracción mínima expresión.
system("PAUSE");
return EXIT_SUCCESS;
}

Escribe número decimal en binario

Como dice el título, este programita, lo que hace es cambiar los sistemas de numeración. Ya que el C ansii, no posee un formato binario, nos servirá cuando necesitemos analizar alguna variable.

#include
#include

int main(void)
{
int dato,anterior,peso;
printf("Ingrese un numero entero decimal positivo:\t");//Pide dato
scanf("%d", &dato);
if (dato>99999 || dato<0)//Pregunta por overflow y cero
{
printf("FUERA DE RANGO\n");
}
else
{
anterior=dato;//conserva el numero ingresado y trabaja con la copia
for (peso=65536;peso!=0;peso>>=1)
{
if (peso<=anterior)//pregunta por el orden de pesos de los caracteres
{
printf("1");//imprime un 1 si el peso corresponde
anterior=anterior-peso;//disminuye el peso para la próxima evaluación
}
else
{
printf("0");//si el 1 no corresponde rellena con 0
}
}
printf("\n");
}
system("PAUSE");
return EXIT_SUCCESS;
}

Cabio de bit (0 por 1 y 1por 0)

Es código lo que hace es el complemento de un número. Es decir, intercambia, los bits 0 por los 1, y los 1 por los ceros. Siempre hablando en números binarios (base 2).


#include
#include


int main(void)
{
int numero,anterior,peso,inverso;
printf("ingrese un numero positivo:");
scanf("%d",&numero);
if (numero>65535 || numero<0)//Pregunta por overflow y cero
{
printf("FUERA DE RANGO\n");
}
else
{
anterior=numero;//conserva el numero ingresado y trabaja con la copia
for (peso=32768;peso!=0;peso>>=1)
{
if (peso<=anterior)//pregunta por el orden de pesos de los caracteres
{
printf("1");//imprime un 1 si el peso corresponde
anterior=anterior-peso;//disminuye el peso para la próxima evaluación
}
else
{
printf("0");//si el 1 no corresponde rellena con 0
}
}
printf("\n");
}
anterior=65535-numero;//conserva el numero ingresado y trabaja con la copia
for (peso=32768;peso!=0;peso>>=1)
{
if (peso<=anterior)//pregunta por el orden de pesos de los caracteres
{
printf("1");//imprime un 1 si el peso corresponde
anterior=anterior-peso;//disminuye el peso para la próxima evaluación
}
else
{
printf("0");//si el 1 no corresponde rellena con 0
}
}
printf("\n");
system("PAUSE");
return EXIT_SUCCESS;
}

Numero decimal a romano

En este ejemplo, se toma un número decimal ingresado por pantalla y devuelve, el número ingresado escrito en números romanos.

#include
#include

int main(void)
{

/*Numeros Romanos
I=1
V=5
X=10
L=50
C=100
D=500
M=1000*/
int N;
printf("ingrese numero decimal:");
scanf("%d",&N);
while(N!=0)
{
switch (N)
{
case N>=1000;
printf("M");
N=N-1000;
break;
case N>=500 && N<1000:
printf("D");
N=N-500;
break;
case N>=100 && N<500:
printf("C");
N=N-100;
break;
case N>=50 && N<100:
printf("L");
N=N-50;
break;
case N>=10 && N<50:
printf("X");
N=N-10;
break;
case N>=5 && N<10:
printf("V");
N=N-5;
break;
case N>=1 && N<5:
printf("I");
N=N-1;
break;
}
system ("PAUSE");
exit(0);
}


Si llegaste hasta acá y no lo encontraste lo que necesitás intentá buscarlo: