evalucacion 4

avaluacion 4

#include <iostream>
#include <math.h>
using namespace std;

const int n=2, m=2;
int i, j, SUMA, PROM, men , M;
int Matriz[n][m], T[n][m], A[n][m], B[n][m], C[n][m];   // DECLARACION
int LeerMatriz();
int SumaElementos();
int ImprimirElementos();
int MatrizIdentidad();
int MatrizTranspuesta();
int SumaMatrices();
int ElementosCentrales();
int Promedio(), MayMen();

int main( )
{
  int Opcion;
  do
  {
  cout<<"***** MENU ************* \n ";
  cout<<"1) LEER UNA MATRIZ   \n";
  cout<<" 2) SUMA DE ELEMENTOS  \n";
  cout<<" 3) IMPRIMIR LOS ELEMENTOS   \n";
  cout<<" 4) MATRIZ IDENTIDAD \n  ";  
  cout<<" 5) MATRIZ TRANSPUESTA \n";    
  cout<<" 6) SUMA DE MATRICES  \n";      
  cout<<" 7) ELEMENTOS CENTRALES MATRICES \n";        
  cout<<" 8) PROMEDIO DE ELEMENTOS DE LA MATRIZ  \n";        
  cout<<" 9) CONTAR LOS MAYORES Y MENORES DE ELEMENTOS DE LA MATRIZ \n \n";
  cout<<"10) DETERMINANTE"      
  cout<<" *********************** \n\n";
  cout<<"       Ingrese una Opcion: "; cin>> Opcion;
 // swhitch
 switch (Opcion)
  { //Inicio Switch
    case 1:
     {
      LeerMatriz();    
     }  
     break;
    case 2:
     {
      SumaElementos();
     }  
     break;
   
   case 3:
     {
      ImprimirElementos();    
     }  
     break;

   case 4:
     {
      MatrizIdentidad();     // INVOCACION
     }  
     break;
   case 5:
     {
      MatrizTranspuesta();   // INVOCACION
     }break;
   case 6:
     {
      SumaMatrices();   // INVOCACION
     }break;
   case 7:
     {
      ElementosCentrales();   // INVOCACION
     }break;
   case 8:
     {
      Promedio();   // INVOCACION
     }break;
    case 9:
     {
      MayMen();   // INVOCACION
     }break;
      case 10:
     {
      Promedio();   // INVOCACION
     }break;
         
  } // Fin Switch
}while(Opcion !=0); // FIN DEL WHILE

 cout<<endl;
 system ("pause");
 return 0;
} // FIN DEL PROGRAMA

// DESARROLLO DE LAS FUNCIONES
int LeerMatriz()
{
 cout<<"***** LEER UNA MATRIZ **** \n";  
 cout<<"Llenar datos a la matriz \n\n";
 for (i=1; i<=n; i++)
  for (j=1; j<=m; j++)    
   {
    cout<<"Matriz["<<i<<"]["<<j<<"] = "; cin>>Matriz[i][j];
   }
 cout<<"************************** \n\n";  
}

int SumaElementos()
{
 cout<<"***** SUMAR LOS ELEMENTOS DE UNA MATRIZ **** \n";  
 SUMA=0;
 for (i=1; i<=n; i++)
  for (j=1; j<=m; j++)    
   {
    SUMA = SUMA + Matriz[i][j];
   }
  cout<<"La suma de los elementos de la Matriz es: "<<SUMA<<endl;
  cout<<"************************** \n\n";  
}

int ImprimirElementos()
{
 cout<<"***** IMPRIMIR LOS ELEMENTOS DE LA MATRIZ **** \n";  
 for (i=1; i<=n; i++)
 for (j=1; j<=m; j++)    
  {
  cout<<"Matriz["<<i<<"]["<<j<<"] = "<<Matriz[i][j]<<endl;
  }
 cout<<"********************************************** \n\n";        
}

int MatrizIdentidad()
{
 cout<<"***** CONVIERTE A UNA MATRIZ IDENTIDAD **** \n";  
 for (i=1; i<=n; i++)
 for (j=1; j<=m; j++)    
  {
    if(i!=j)
     Matriz[i][j] = Matriz[i][j] * 0;
    if (i==j)
     Matriz[i][j] = Matriz[i][j] / Matriz[i][j];
  }
 cout<<"********************************************** \n\n";        
}

int MatrizTranspuesta()
{
 cout<<"***** CONVIERTE A UNA MATRIZ IDENTIDAD **** \n";  
 for (i=1; i<=n; i++)
 for (j=1; j<=m; j++)    
  {
    if(i!=j)
     T[i][j] = Matriz[j][i];
  }
  // IMPRESION DE LOS ELEMENTOS DE LA MATRIZ
 for (i=1; i<=n; i++)
 for (j=1; j<=m; j++)    
  {
  cout<<"T["<<i<<"]["<<j<<"] = "<< T[i][j]<<endl;
  }
 cout<<"********************************************** \n\n";        
}

int SumaMatrices()
{
 cout<<"***** SUMA DE MATRICES ******************** \n";  
 cout<<"Lectura de la Matriz A[n][m] \n ";
 for (i=1; i<=n; i++)
 for (j=1; j<=m; j++)    
  {
   cout<<"A["<<i<<"]["<<j<<"] = "; cin>>A[i][j];
  }
 cout<<"Lectura de la Matriz B[n][m] \n ";
 for (i=1; i<=n; i++)
 for (j=1; j<=m; j++)    
  {
   cout<<"B["<<i<<"]["<<j<<"] = "; cin>>B[i][j];
  }
  // PROCESO
 for (i=1; i<=n; i++)
 for (j=1; j<=m; j++)    
  {
   C[i][j] = A[i][j] + B[i][j];
  }
  // RESULTADO
  cout<<"LA SUMA DE LAS MATRICES A[n][m]+B[n][m] ES: \n\n";
 for (i=1; i<=n; i++)
 for (j=1; j<=m; j++)    
  {
  cout<<"C["<<i<<"]["<<j<<"] = "<< C[i][j]<<endl;
  }
 cout<<"********************************************** \n\n";        
}

int ElementosCentrales()
{
 cout<<"*********ELEMENTOS CENTRALES************************* \n\n";        

 for (i=1; i<=n; i++)
 for (j=1; j<=m; j++)    
  {
   if(i==j)
    cout<<"Matriz["<<i<<"]["<<j<<"] = "<< Matriz[i][j]<<endl;
  }
 cout<<"********************************************** \n\n";        

}

int Promedio()
{
 cout<<"********* PROMEDIO DE LOS ELEMENTOS ************************* \n\n";        
 SUMA=0;
 for (i=1; i<=n; i++)
 for (j=1; j<=m; j++)    
  {
   SUMA = SUMA + Matriz[i][j];
  }
  PROM = SUMA/(n*m);
  cout<<"El promedio de la Matriz es: "<<PROM <<endl;
 cout<<"************************************************************* \n\n";        
}

int MayMen()
{
 M=0;  
 men=0;
 for (i=1; i<=n; i++)
 for (j=1; j<=m; j++)    
  {
   if (Matriz[i][j]>PROM)
     M = M + 1;
   if (Matriz[i][j]<PROM)
     men = men + 1;
  }
 cout<<"Tiene "<< M << "Valores Mayores al promedio de"<< PROM <<endl;
 cout<<"Tiene "<< men << "Valores Menores al promedio de"<< PROM <<endl;
}

int determinante()
{
cout<<"********* determinante de una matriz ************** \n\n";
double det(double **m, int b)
{
   double determinante = 0, aux = 0;
   int c;
   if(b==2)
      return m[0][0]*m[1][1] - m[1][0]*m[0][1];
   else
   {
      for(int j=0; j < b; j++)
      {
         double **menor=(double **)malloc(sizeof(double)*(b-1));
         for(int h=0; h < (b-1); h++)
             menor[h] = (double *)malloc(sizeof(double)*(b-1));
         for(int k=1; k < b; k++)
         {
             c = 0;
             for(int l=0; l < b; l++)
             {
                 if(l!=j)
                 {
                     menor[k-1][c] = m[k][l];
                     c++;
                 }
             }
          }
          aux = pow(-1, 2+j)*m[0][j]*det(menor, b-1);
          determinante += aux;
          for(int q = 0; q < (b-1); q++)
               free(menor[q]);
          free(menor);
      }
      return determinante;
   }
}

Ingenieros estadounidenses construyen el primer ordenador con nanotubos de carbono

En una búsqueda de nuevos materiales que sustituyan al silicio para crear equipos electrónicos más eficientes y de tamaño más reducido, ingenieros de la Universidad de Stanford (EE UU) han logrado construir por primera vez un ordenador hecho íntegramente con transistores de nanotubos de carbono (CNT, por sus siglas en inglés).
Se trata de un dispositivo todavía muy básico, pero que incluye un sistema operativo y es capaz de ejecutar varios programas al mismo tiempo
Los autores del proyecto, cuyos resultados se publican en el último número de Nature, señalan que este avance culmina años de esfuerzos por parte de científicos de todo el mundo para aprovechar este prometedor pero peculiar material.
Según explica a SINC Max Shulaker, autor principal del trabajo, “los nanotubos de carbono representan un importante avance respecto a los actuales transistores de silicio y prevemos grandes mejoras tanto en el rendimiento como en la eficiencia energética”.
Los nanotubos de carbono son largas cadenas de átomos extremadamente eficientes en la conducción y el control de la electricidad. “Son tan finos que miles de ellos podrían caber unos junto a otros en un cabello humano y requieren muy poca energía para apagarlos”, indica.

 

Shulake añade que el trabajo demuestra que es posible fabricar nanotubos de carbono, pese a que esta tecnología tiene aún imperfecciones inherentes. “Sin embargo, nosotros hemos logrado superar estos obstáculos y presentar el sistema basado en carbono más avanzado hasta la fecha”, subraya.
Entre las dificultades que tiene trabajar con este material destaca que los nanotubos de carbono no crecen en líneas paralelas, como a los fabricantes de chips les gustaría. Otro problema es que una porción de estos nanotubos pueden acabar comportándose como cables metálicos que siempre conducen electricidad en vez de comportarse como semiconductores que pueden apagarse, señala la Universidad de Stanford en un comunicado.

Para superar estos obstáculos, el equipo llevó a cabo un diseño que llamó “inmune a imperfecciones” que consistió en eliminar los nanotubos que se comportaban como cables. Luego apagó todos los CNT ‘buenos’ y bombeó el circuito semiconductor lleno de electricidad.

Toda esa electricidad se concentró en los nanotubos metálicos, que se calentaron tanto que se quemaron y, literalmente, se vaporizaron convirtiéndose en dióxido de carbono. “Esta sofisticada técnica eliminó todos los CNT metálicos del circuito”, indican estas fuentes.

Evitar los nanotubos desalineados requirió aún mayor sutileza”, señalan los autores. Para ello, los investigadores crearon un potente algoritmo que traza un esquema del circuito y que garantiza que funcione sin importar si los nanotutbos están o no torcidos.
Los ingenieros utilizaron este diseño inmune a imperfecciones para ensamblar un ordenador básico con 178 transistores, un límite que vino dado por que utilizaron las instalaciones de la universidad, en vez de un proceso de fabricación industrial, aclaran.

Varias tareas
El ordenador fue capaz de realizar tareas como contar y ordenar números. Además, incorpora un sistema operativo básico que permite llevar a cabo intercambio de esos procesos. Para mostrar su potencial, los investigadores probaron que el dispositivo también podía ejecutar una instrucción comercial denominada MIPS (Microprocessor without Interlocked Pipeline Stages), desarrollada a comienzos de la década de los ochenta del siglo pasado por John Hennessy, ingeniero y actual presidente de la Universidad de Stanford.
Por su parte, Franz Kreupl, investigador de sistemas electrónicos híbridos de la Universidad de Munich (Alemania) y autor de una reseña sobre el proyecto, que también ha sido publicada en en Nature, indica a SINC que trabajos tanto teóricos como experimentales “han demostrado que los nanotubos de carbono son los interruptores electrónicos de mayor eficiencia energética con una escalabilidad muy por debajo de los 10 nanómetros”.
En su opinión, el trabajo de Shulaker y su equipo es muy valioso, ya que ha podido superar las dificultades que tiene trabajar con nanotubos de carbono y construir el primer ordenador funcional con este nuevo material emergente, “muy superior en este tipo de aplicaciones a competidores como el grafeno”.
Para concluir, los autores del trabajo señalan que la demostración del nuevo dispositivo confirma que los nanotubos de carbono son una tecnología factible para desarrollar la próxima generación de sistemas electrónicos de alta eficiencia energética.

 

programacion :se refiere a idear y ordenar las acciones que se realizarán en el marco de un proyecto; al anuncio de las partes que componen un acto o espectáculo; a la preparación de máquinas para que cumplan con una cierta tarea en un momento determinado; a la elaboración de programas para la resolución de problemas mediante ordenadores; y a la preparación de los datos necesarios para obtener una solución de un problema a través de una calculadora electrónica, por ejemplo.

bienvenidos a mi nuevo blog

nada por ahora