Menú

Mostrar Mensajes

Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.

Mostrar Mensajes Menú

Mensajes - karurosu

Páginas 1 2 3 4 5 6 7
#61
Dudas y pedidos generales / Re:[SOLUCIONADO] Office 2016
Marzo 05, 2018, 04:17:54 PM
Hola buen día, está prohibido compartir cracks, keygen y todo tipo de activadores, te recomiendo que busques en Google y también que leas las  reglas del foro, ¡saludos!

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
#62
Dudas y pedidos generales / Re:Problema con controles Xbox 360
Febrero 23, 2018, 03:52:13 PM
Hola, gracias por la sugerencia Doster, ya lo he hecho anteriormente pero sigue el problema  :(

#63
Dudas y pedidos generales / Problema con controles Xbox 360
Febrero 22, 2018, 04:07:20 PM
Hola qué tal, hace tiempo que utilizo para jugar en mi laptop unos controles de xbox 360, hace poco decidí comprar un juego en Steam y cuando conecté los controles pareciera que el driver se instaló de nuevo o se configuró para Steam (era la primera vez que los conectaba con Steam abierto), luego de eso me dan como "falso contacto", ya que a cada rato mientras tengo el juego abierto me dice que el control se deconecta y suena el pitido típico del USB desconectándose, ya reinstalé los drivers y limpié caché y errores de registro pero nada ha funcionado, contacté a Microsoft y su solución es formatear el equipo, ¿algún consejo?, ¡saludos!
#64
Off Topic / Re:¿Cuál fue tu inicio en la informática?
Enero 12, 2018, 01:05:55 PM
¡Hola!

Recuerdo que mi primer contacto con una computadora fue cuando tenía como ocho años, me regaló un tío su equipo viejo con Windows 98, ni siquiera tenía internet pero me divertía con Encarta y hasta escribí un cuento bastante largo en Word XD

A partir de ahí no me separé de las computadoras, investigué muchas cosas, al inicio sobre creación de videojuegos, hice un juego en RPGMaker recuerdo, lamentablemente todo eso lo perdí.

Mi primera vez programando fue mucho después, luego de que no logré entrar a la universidad me dediqué por ese año a aprender C, poco a poco fui investigando más hasta que llegue a este foro en el 2011, hice un gran amigo acá (David) y juntos aprendimos un poco con los tutoriales de Ricardo Narvaja sobre el OllyDBG.

¡Saludos!

#65
Presentaciones y cumpleaños / Re:TGP Presentación
Enero 11, 2018, 07:48:51 PM
¡Bienvenido! ojalá aprendas mucho y cualquier duda o aporte no dudes en dejarlo acá, te lo agradeceremos todos, ¡saludos!

:) :) :)
#66
Dudas y pedidos generales / Re:CRC falló en el nombre del archivo
Enero 11, 2018, 07:46:11 PM
Hola, ¿sólo te pasa con un sólo archivo o con todos los .rar? puedes intentar volver a bajar el archivo en caso de que te suceda solo con uno, al momento de descomprimir te darás cuenta cuál es el archivo donde para el proceso y da error, otra opción es intentar reparar el archivo con Winrar.

En caso de que sea algo general puedes intentar reinstalar Winrar quizá se daño algún archivo del programa o intenta descomprimir con otro programa a ver si te da el mismo error, ¡saludos!  :D
#67
Presentaciones y cumpleaños / Re:Mi presentación.
Enero 06, 2018, 03:14:49 PM
¡Bienvenido! ojalá aprendas mucho y cualquier cosa aquí andamos.

  ;D ;D ;D
#68
Off Topic / Re:¿Desde qué rincón del mundo nos escribes?
Enero 05, 2018, 09:24:28 PM
¡Hola!

Yo soy de México, de un estado que se llama Veracruz, estoy en el foro desde el 2011 y lo dejé por trabajo, ahora espero ser un poco más activo, ¡saludos a todos!  :D
#69
Cursos, manuales y libros / Re:[APORTE] Atajos útiles
Mayo 08, 2017, 07:33:23 PM
Muy buen aporte, gracias por compartir, ¡saludos! :)
#70
C / C++ / Re:Perceptrón en C
Mayo 12, 2016, 05:03:22 PM
Hola, buenas tardes, el formato es el siguiente:

Citarp1

0   0   0   0   0   0   0   0
0   0   0   0   1   1   0   0
0   0   0   0   1   1   0   0
0   0   0   0   1   1   0   0
0   0   0   0   1   1   0   0
0   0   0   0   1   1   0   0
0   0   0   0   1   1   0   0
0   0   0   0   0   0   0   0

1

con el numero de patrón primeramente y luego los elementos del patrón, por último va la salida deseada, que en este caso es 1, y así todos los patrones hasta el 20 en mi caso, ¡saludos!
#71
C / C++ / Perceptrón en C
Marzo 30, 2016, 02:22:13 PM
Buenas, les quiero compartir este código que recién hice, se trata de un perceptrón hecho en C, en mi caso analiza 20 patrones con 64 elementos cada uno (más el primer elemento por default siendo 65), todo lo leo de un archivo .txt lo almaceno en arreglos y realizo las operaciones, para los que no saben que es un perceptrón es un método para comparar patrones que pueden ser linealmente separables, esto verifica que cierto patrón coincida con un valor, en mi caso debe coincidir con las salidas deseadas de mi .txt, en fin les dejo el código:

Código: c
#include <stdio.h>
#include <stdlib.h>

//Declaración de variables globales
char numeroPatron[20][2];
int patrones[20][65];
float salidaDeseada[20];
float pesos[65];
int contadorElementos, contadorPatrones;
float FP[20];
int SP [20];

//Paso 1 se lee el archivo que contiene los patrones
void leerArchivo()
{
     int contadorPatron, contadorNumeros1, contadorNumeros2;
     
     contadorNumeros1 = 0;
     
     printf("Los patrones son: \n");
     
     //Se declara un apuntador al archivo
     FILE * fichero;
     //Se abre el archivo para lectura con "r"
     fichero = fopen ("patrones.txt", "r");
     
     contadorPatrones = 0;
     for (contadorPatron = 0; contadorPatron < 20; contadorPatron++)
     {
         contadorElementos = 1;
         contadorPatrones++;
         //Se lee el valor del documento y se guarda en el arreglo
         fscanf(fichero, "%s", &numeroPatron[contadorPatron]);
         printf("%s\n", numeroPatron[contadorPatron]);
         patrones [contadorNumeros1][0] = 1;
         printf("%d", patrones[contadorNumeros1][0]);
         
         for (contadorNumeros2 = 1; contadorNumeros2 < 65; contadorNumeros2++)
         {
             fscanf(fichero, "%d", &patrones[contadorNumeros1][contadorNumeros2]);
             printf("%d", patrones[contadorNumeros1][contadorNumeros2]);
             contadorElementos++;
         }
         
         fscanf(fichero, "%f", &salidaDeseada[contadorPatron]);
         printf("\n%.2f\n", salidaDeseada[contadorPatron]);
         
         contadorNumeros1++;
     }
     //Se cierra el archivo
     fclose(fichero);
}

void primerosPesos()
{
     int x;
     time_t t;
     
     sleep(5000);
     system("CLS");
         
     srand((unsigned) time(&t));
     printf ("Pesos\n\n");
     for (x = 0; x < contadorElementos; x++)
     {
         pesos [x] = rand() % 201;
         if (pesos[x] <= 100)
         {
            pesos [x] = pesos[x] / -100;             
         }else
         {
            pesos [x] = pesos[x] / 200;
         }
         printf("w%d = %.2f\n", x, pesos[x]);
     }    
}

void recalcularPesos(int y, int bandera)
    {
         int x, z;
         float n = 0.1;
         
         printf("Los nuevos pesos son: \n");
         for(x = 0; x < contadorElementos; x++)
         {
               if (bandera == 1){
                           pesos[x] = pesos[x] + n * patrones [y] [x];
               }
               if (bandera == 0){
                           pesos[x] = pesos[x] - n * patrones [y] [x];
               }
               printf("w%d = %.2f\n", x + 1, pesos[x]);
         }
         printf("\n\n");
    }

void funcionPropagacion()
    {
         int x, y, umbral = 0, malclasificados = 0, bandera1;
         
         printf ("\nCalculando funcion de propagacion y salida del Perceptron\n\n");  
               
               for (x = 0; x < contadorPatrones; x++)
               {
                   FP [x] = 0;
               }
               
               for (x = 0; x < contadorPatrones; x++)
               {
                 printf ("FP%d = ", x + 1);
                 for (y = 0; y < contadorElementos; y++)
                 {
                     FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                     printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                 }
                 printf ("= %.2f\n", FP[x]);
                 
                 if(FP [x] > umbral)
                 {
                       SP[x] = 1;
                 }
                 else{
                      SP[x] = -1;
                 }
                 printf ("SP%d = %d\n", x + 1, SP[x]);
                 if (salidaDeseada [x] != SP[x])
                 {
                       malclasificados = malclasificados + 1;
                 }
             }
             printf ("Los mal clasificados son %d\n", malclasificados);
             sleep(5000);
             while(malclasificados > 0)
             {
                                   system("CLS");
                                   malclasificados = 0;
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                       FP [x] = 0;
                                   }
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                     printf ("FP%d = ", x + 1);
                                     for (y = 0; y < contadorElementos; y++)
                                     {
                                         FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                                         printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                                     }
                                     printf ("= %.2f\n", FP[x]);
                                     
                                     if(FP [x] > umbral)
                                     {
                                           SP[x] = 1;
                                     }
                                     else{
                                          SP[x] = -1;
                                     }
                                     printf ("SP%d = %d\n", x + 1, SP[x]);
                                     if (salidaDeseada [x] != SP[x])
                                     {
                                           printf("\nLos valores son distintos se recalcularan los pesos...\n");
                                           system("CLS");
                                           if (SP[x] < salidaDeseada [x])
                                           {
                                                     bandera1 = 1;
                                           }else{
                                                     bandera1 = 0;
                                           }
                                           recalcularPesos(x, bandera1);
                                           malclasificados = malclasificados + 1;
                                     }
                                 }
               }                       
    
         printf ("\nLas salidas son las deseadas!\n\n");
         printf ("Los pesos son:\n");
         for (x = 0; x < contadorElementos; x++)
         {
             printf ("w%d = %.2f\n", x + 1, pesos[x]);
         }
}

int main()
{
  leerArchivo();
  primerosPesos();
  funcionPropagacion();
  system("PAUSE");	
}   


Espero que le sirva a alguien, saludos.  :)
#72
C / C++ / Perceptrón en C
Marzo 29, 2016, 04:33:10 PM
Buenas, les quiero compartir este código que recién hice, se trata de un perceptrón hecho en C, en mi caso analiza 20 patrones con 64 elementos cada uno (más el primer elemento por default siendo 65), todo lo leo de un archivo .txt lo almaceno en arreglos y realizo las operaciones, para los que no saben que es un perceptrón es un método para comparar patrones que pueden ser linealmente separables, esto verifica que cierto patrón coincida con un valor, en mi caso debe coincidir con las salidas deseadas de mi .txt, en fin les dejo el código:

Código: text
#include <stdio.h>
#include <stdlib.h>

//Declaración de variables globales
char numeroPatron[20][2];
int patrones[20][65];
float salidaDeseada[20];
float pesos[65];
int contadorElementos, contadorPatrones;
float FP[20];
int SP [20];

//Paso 1 se lee el archivo que contiene los patrones
void leerArchivo()
{
     int contadorPatron, contadorNumeros1, contadorNumeros2;
     
     contadorNumeros1 = 0;
     
     printf("Los patrones son: \n");
     
     //Se declara un apuntador al archivo
     FILE * fichero;
     //Se abre el archivo para lectura con "r"
     fichero = fopen ("patrones.txt", "r");
     
     contadorPatrones = 0;
     for (contadorPatron = 0; contadorPatron < 20; contadorPatron++)
     {
         contadorElementos = 1;
         contadorPatrones++;
         //Se lee el valor del documento y se guarda en el arreglo
         fscanf(fichero, "%s", &numeroPatron[contadorPatron]);
         printf("%s\n", numeroPatron[contadorPatron]);
         patrones [contadorNumeros1][0] = 1;
         printf("%d", patrones[contadorNumeros1][0]);
         
         for (contadorNumeros2 = 1; contadorNumeros2 < 65; contadorNumeros2++)
         {
             fscanf(fichero, "%d", &patrones[contadorNumeros1][contadorNumeros2]);
             printf("%d", patrones[contadorNumeros1][contadorNumeros2]);
             contadorElementos++;
         }
         
         fscanf(fichero, "%f", &salidaDeseada[contadorPatron]);
         printf("\n%.2f\n", salidaDeseada[contadorPatron]);
         
         contadorNumeros1++;
     }
     //Se cierra el archivo
     fclose(fichero);
}

void primerosPesos()
{
     int x;
     time_t t;
     
     sleep(5000);
     system("CLS");
         
     srand((unsigned) time(&t));
     printf ("Pesos\n\n");
     for (x = 0; x < contadorElementos; x++)
     {
         pesos [x] = rand() % 201;
         if (pesos[x] <= 100)
         {
            pesos [x] = pesos[x] / -100;             
         }else
         {
            pesos [x] = pesos[x] / 200;
         }
         printf("w%d = %.2f\n", x, pesos[x]);
     }    
}

void recalcularPesos(int y, int bandera)
    {
         int x, z;
         float n = 0.1;
         
         printf("Los nuevos pesos son: \n");
         for(x = 0; x < contadorElementos; x++)
         {
               if (bandera == 1){
                           pesos[x] = pesos[x] + n * patrones [y] [x];
               }
               if (bandera == 0){
                           pesos[x] = pesos[x] - n * patrones [y] [x];
               }
               printf("w%d = %.2f\n", x + 1, pesos[x]);
         }
         printf("\n\n");
    }

void funcionPropagacion()
    {
         int x, y, umbral = 0, malclasificados = 0, bandera1;
         
         printf ("\nCalculando funcion de propagacion y salida del Perceptron\n\n");  
               
               for (x = 0; x < contadorPatrones; x++)
               {
                   FP [x] = 0;
               }
               
               for (x = 0; x < contadorPatrones; x++)
               {
                 printf ("FP%d = ", x + 1);
                 for (y = 0; y < contadorElementos; y++)
                 {
                     FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                     printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                 }
                 printf ("= %.2f\n", FP[x]);
                 
                 if(FP [x] > umbral)
                 {
                       SP[x] = 1;
                 }
                 else{
                      SP[x] = -1;
                 }
                 printf ("SP%d = %d\n", x + 1, SP[x]);
                 if (salidaDeseada [x] != SP[x])
                 {
                       malclasificados = malclasificados + 1;
                 }
             }
             printf ("Los mal clasificados son %d\n", malclasificados);
             sleep(5000);
             while(malclasificados > 0)
             {
                                   system("CLS");
                                   malclasificados = 0;
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                       FP [x] = 0;
                                   }
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                     printf ("FP%d = ", x + 1);
                                     for (y = 0; y < contadorElementos; y++)
                                     {
                                         FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                                         printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                                     }
                                     printf ("= %.2f\n", FP[x]);
                                     
                                     if(FP [x] > umbral)
                                     {
                                           SP[x] = 1;
                                     }
                                     else{
                                          SP[x] = -1;
                                     }
                                     printf ("SP%d = %d\n", x + 1, SP[x]);
                                     if (salidaDeseada [x] != SP[x])
                                     {
                                           printf("\nLos valores son distintos se recalcularan los pesos...\n");
                                           system("CLS");
                                           if (SP[x] < salidaDeseada [x])
                                           {
                                                     bandera1 = 1;
                                           }else{
                                                     bandera1 = 0;
                                           }
                                           recalcularPesos(x, bandera1);
                                           malclasificados = malclasificados + 1;
                                     }
                                 }
               }                       
    
         printf ("\nLas salidas son las deseadas!\n\n");
         printf ("Los pesos son:\n");
         for (x = 0; x < contadorElementos; x++)
         {
             printf ("w%d = %.2f\n", x + 1, pesos[x]);
         }
}

int main()
{
  leerArchivo();
  primerosPesos();
  funcionPropagacion();
  system("PAUSE");	
}   


Espero que le sirva a alguien, saludos.  :)
#73
C / C++ / Perceptrón en C
Marzo 29, 2016, 04:32:34 PM
Buenas, les quiero compartir este código que recién hice, se trata de un perceptrón hecho en C, en mi caso analiza 20 patrones con 64 elementos cada uno (más el primer elemento por default siendo 65), todo lo leo de un archivo .txt lo almaceno en arreglos y realizo las operaciones, para los que no saben que es un perceptrón es un método para comparar patrones que pueden ser linealmente separables, esto verifica que cierto patrón coincida con un valor, en mi caso debe coincidir con las salidas deseadas de mi .txt, en fin les dejo el código:

Código: text
#include <stdio.h>
#include <stdlib.h>

//Declaración de variables globales
char numeroPatron[20][2];
int patrones[20][65];
float salidaDeseada[20];
float pesos[65];
int contadorElementos, contadorPatrones;
float FP[20];
int SP [20];

//Paso 1 se lee el archivo que contiene los patrones
void leerArchivo()
{
     int contadorPatron, contadorNumeros1, contadorNumeros2;
     
     contadorNumeros1 = 0;
     
     printf("Los patrones son: \n");
     
     //Se declara un apuntador al archivo
     FILE * fichero;
     //Se abre el archivo para lectura con "r"
     fichero = fopen ("patrones.txt", "r");
     
     contadorPatrones = 0;
     for (contadorPatron = 0; contadorPatron < 20; contadorPatron++)
     {
         contadorElementos = 1;
         contadorPatrones++;
         //Se lee el valor del documento y se guarda en el arreglo
         fscanf(fichero, "%s", &numeroPatron[contadorPatron]);
         printf("%s\n", numeroPatron[contadorPatron]);
         patrones [contadorNumeros1][0] = 1;
         printf("%d", patrones[contadorNumeros1][0]);
         
         for (contadorNumeros2 = 1; contadorNumeros2 < 65; contadorNumeros2++)
         {
             fscanf(fichero, "%d", &patrones[contadorNumeros1][contadorNumeros2]);
             printf("%d", patrones[contadorNumeros1][contadorNumeros2]);
             contadorElementos++;
         }
         
         fscanf(fichero, "%f", &salidaDeseada[contadorPatron]);
         printf("\n%.2f\n", salidaDeseada[contadorPatron]);
         
         contadorNumeros1++;
     }
     //Se cierra el archivo
     fclose(fichero);
}

void primerosPesos()
{
     int x;
     time_t t;
     
     sleep(5000);
     system("CLS");
         
     srand((unsigned) time(&t));
     printf ("Pesos\n\n");
     for (x = 0; x < contadorElementos; x++)
     {
         pesos [x] = rand() % 201;
         if (pesos[x] <= 100)
         {
            pesos [x] = pesos[x] / -100;             
         }else
         {
            pesos [x] = pesos[x] / 200;
         }
         printf("w%d = %.2f\n", x, pesos[x]);
     }    
}

void recalcularPesos(int y, int bandera)
    {
         int x, z;
         float n = 0.1;
         
         printf("Los nuevos pesos son: \n");
         for(x = 0; x < contadorElementos; x++)
         {
               if (bandera == 1){
                           pesos[x] = pesos[x] + n * patrones [y] [x];
               }
               if (bandera == 0){
                           pesos[x] = pesos[x] - n * patrones [y] [x];
               }
               printf("w%d = %.2f\n", x + 1, pesos[x]);
         }
         printf("\n\n");
    }

void funcionPropagacion()
    {
         int x, y, umbral = 0, malclasificados = 0, bandera1;
         
         printf ("\nCalculando funcion de propagacion y salida del Perceptron\n\n");  
               
               for (x = 0; x < contadorPatrones; x++)
               {
                   FP [x] = 0;
               }
               
               for (x = 0; x < contadorPatrones; x++)
               {
                 printf ("FP%d = ", x + 1);
                 for (y = 0; y < contadorElementos; y++)
                 {
                     FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                     printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                 }
                 printf ("= %.2f\n", FP[x]);
                 
                 if(FP [x] > umbral)
                 {
                       SP[x] = 1;
                 }
                 else{
                      SP[x] = -1;
                 }
                 printf ("SP%d = %d\n", x + 1, SP[x]);
                 if (salidaDeseada [x] != SP[x])
                 {
                       malclasificados = malclasificados + 1;
                 }
             }
             printf ("Los mal clasificados son %d\n", malclasificados);
             sleep(5000);
             while(malclasificados > 0)
             {
                                   system("CLS");
                                   malclasificados = 0;
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                       FP [x] = 0;
                                   }
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                     printf ("FP%d = ", x + 1);
                                     for (y = 0; y < contadorElementos; y++)
                                     {
                                         FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                                         printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                                     }
                                     printf ("= %.2f\n", FP[x]);
                                     
                                     if(FP [x] > umbral)
                                     {
                                           SP[x] = 1;
                                     }
                                     else{
                                          SP[x] = -1;
                                     }
                                     printf ("SP%d = %d\n", x + 1, SP[x]);
                                     if (salidaDeseada [x] != SP[x])
                                     {
                                           printf("\nLos valores son distintos se recalcularan los pesos...\n");
                                           system("CLS");
                                           if (SP[x] < salidaDeseada [x])
                                           {
                                                     bandera1 = 1;
                                           }else{
                                                     bandera1 = 0;
                                           }
                                           recalcularPesos(x, bandera1);
                                           malclasificados = malclasificados + 1;
                                     }
                                 }
               }                       
    
         printf ("\nLas salidas son las deseadas!\n\n");
         printf ("Los pesos son:\n");
         for (x = 0; x < contadorElementos; x++)
         {
             printf ("w%d = %.2f\n", x + 1, pesos[x]);
         }
}

int main()
{
  leerArchivo();
  primerosPesos();
  funcionPropagacion();
  system("PAUSE");	
}   


Espero que le sirva a alguien, saludos.  :)
#74
C / C++ / Perceptrón en C
Marzo 29, 2016, 04:28:46 PM
Buenas, les quiero compartir este código que recién hice, se trata de un perceptrón hecho en C, en mi caso analiza 20 patrones con 64 elementos cada uno (más el primer elemento por default siendo 65), todo lo leo de un archivo .txt lo almaceno en arreglos y realizo las operaciones, para los que no saben que es un perceptrón es un método para comparar patrones que pueden ser linealmente separables, esto verifica que cierto patrón coincida con un valor, en mi caso debe coincidir con las salidas deseadas de mi .txt, en fin les dejo el código:

Código: text
#include <stdio.h>
#include <stdlib.h>

//Declaración de variables globales
char numeroPatron[20][2];
int patrones[20][65];
float salidaDeseada[20];
float pesos[65];
int contadorElementos, contadorPatrones;
float FP[20];
int SP [20];

//Paso 1 se lee el archivo que contiene los patrones
void leerArchivo()
{
     int contadorPatron, contadorNumeros1, contadorNumeros2;
     
     contadorNumeros1 = 0;
     
     printf("Los patrones son: \n");
     
     //Se declara un apuntador al archivo
     FILE * fichero;
     //Se abre el archivo para lectura con "r"
     fichero = fopen ("patrones.txt", "r");
     
     contadorPatrones = 0;
     for (contadorPatron = 0; contadorPatron < 20; contadorPatron++)
     {
         contadorElementos = 1;
         contadorPatrones++;
         //Se lee el valor del documento y se guarda en el arreglo
         fscanf(fichero, "%s", &numeroPatron[contadorPatron]);
         printf("%s\n", numeroPatron[contadorPatron]);
         patrones [contadorNumeros1][0] = 1;
         printf("%d", patrones[contadorNumeros1][0]);
         
         for (contadorNumeros2 = 1; contadorNumeros2 < 65; contadorNumeros2++)
         {
             fscanf(fichero, "%d", &patrones[contadorNumeros1][contadorNumeros2]);
             printf("%d", patrones[contadorNumeros1][contadorNumeros2]);
             contadorElementos++;
         }
         
         fscanf(fichero, "%f", &salidaDeseada[contadorPatron]);
         printf("\n%.2f\n", salidaDeseada[contadorPatron]);
         
         contadorNumeros1++;
     }
     //Se cierra el archivo
     fclose(fichero);
}

void primerosPesos()
{
     int x;
     time_t t;
     
     sleep(5000);
     system("CLS");
         
     srand((unsigned) time(&t));
     printf ("Pesos\n\n");
     for (x = 0; x < contadorElementos; x++)
     {
         pesos [x] = rand() % 201;
         if (pesos[x] <= 100)
         {
            pesos [x] = pesos[x] / -100;             
         }else
         {
            pesos [x] = pesos[x] / 200;
         }
         printf("w%d = %.2f\n", x, pesos[x]);
     }    
}

void recalcularPesos(int y, int bandera)
    {
         int x, z;
         float n = 0.1;
         
         printf("Los nuevos pesos son: \n");
         for(x = 0; x < contadorElementos; x++)
         {
               if (bandera == 1){
                           pesos[x] = pesos[x] + n * patrones [y] [x];
               }
               if (bandera == 0){
                           pesos[x] = pesos[x] - n * patrones [y] [x];
               }
               printf("w%d = %.2f\n", x + 1, pesos[x]);
         }
         printf("\n\n");
    }

void funcionPropagacion()
    {
         int x, y, umbral = 0, malclasificados = 0, bandera1;
         
         printf ("\nCalculando funcion de propagacion y salida del Perceptron\n\n");  
               
               for (x = 0; x < contadorPatrones; x++)
               {
                   FP [x] = 0;
               }
               
               for (x = 0; x < contadorPatrones; x++)
               {
                 printf ("FP%d = ", x + 1);
                 for (y = 0; y < contadorElementos; y++)
                 {
                     FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                     printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                 }
                 printf ("= %.2f\n", FP[x]);
                 
                 if(FP [x] > umbral)
                 {
                       SP[x] = 1;
                 }
                 else{
                      SP[x] = -1;
                 }
                 printf ("SP%d = %d\n", x + 1, SP[x]);
                 if (salidaDeseada [x] != SP[x])
                 {
                       malclasificados = malclasificados + 1;
                 }
             }
             printf ("Los mal clasificados son %d\n", malclasificados);
             sleep(5000);
             while(malclasificados > 0)
             {
                                   system("CLS");
                                   malclasificados = 0;
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                       FP [x] = 0;
                                   }
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                     printf ("FP%d = ", x + 1);
                                     for (y = 0; y < contadorElementos; y++)
                                     {
                                         FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                                         printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                                     }
                                     printf ("= %.2f\n", FP[x]);
                                     
                                     if(FP [x] > umbral)
                                     {
                                           SP[x] = 1;
                                     }
                                     else{
                                          SP[x] = -1;
                                     }
                                     printf ("SP%d = %d\n", x + 1, SP[x]);
                                     if (salidaDeseada [x] != SP[x])
                                     {
                                           printf("\nLos valores son distintos se recalcularan los pesos...\n");
                                           system("CLS");
                                           if (SP[x] < salidaDeseada [x])
                                           {
                                                     bandera1 = 1;
                                           }else{
                                                     bandera1 = 0;
                                           }
                                           recalcularPesos(x, bandera1);
                                           malclasificados = malclasificados + 1;
                                     }
                                 }
               }                       
    
         printf ("\nLas salidas son las deseadas!\n\n");
         printf ("Los pesos son:\n");
         for (x = 0; x < contadorElementos; x++)
         {
             printf ("w%d = %.2f\n", x + 1, pesos[x]);
         }
}

int main()
{
  leerArchivo();
  primerosPesos();
  funcionPropagacion();
  system("PAUSE");	
}   


Espero que le sirva a alguien, saludos.  :)
#75
C / C++ / Perceptrón en C
Marzo 29, 2016, 04:25:33 PM
Buenas, les quiero compartir este código que recién hice, se trata de un perceptrón hecho en C, en mi caso analiza 20 patrones con 64 elementos cada uno (más el primer elemento por default siendo 65), todo lo leo de un archivo .txt lo almaceno en arreglos y realizo las operaciones, para los que no saben que es un perceptrón es un método para comparar patrones que pueden ser linealmente separables, esto verifica que cierto patrón coincida con un valor, en mi caso debe coincidir con las salidas deseadas de mi .txt, en fin les dejo el código:

Código: text
#include <stdio.h>
#include <stdlib.h>

//Declaración de variables globales
char numeroPatron[20][2];
int patrones[20][65];
float salidaDeseada[20];
float pesos[65];
int contadorElementos, contadorPatrones;
float FP[20];
int SP [20];

//Paso 1 se lee el archivo que contiene los patrones
void leerArchivo()
{
     int contadorPatron, contadorNumeros1, contadorNumeros2;
     
     contadorNumeros1 = 0;
     
     printf("Los patrones son: \n");
     
     //Se declara un apuntador al archivo
     FILE * fichero;
     //Se abre el archivo para lectura con "r"
     fichero = fopen ("patrones.txt", "r");
     
     contadorPatrones = 0;
     for (contadorPatron = 0; contadorPatron < 20; contadorPatron++)
     {
         contadorElementos = 1;
         contadorPatrones++;
         //Se lee el valor del documento y se guarda en el arreglo
         fscanf(fichero, "%s", &numeroPatron[contadorPatron]);
         printf("%s\n", numeroPatron[contadorPatron]);
         patrones [contadorNumeros1][0] = 1;
         printf("%d", patrones[contadorNumeros1][0]);
         
         for (contadorNumeros2 = 1; contadorNumeros2 < 65; contadorNumeros2++)
         {
             fscanf(fichero, "%d", &patrones[contadorNumeros1][contadorNumeros2]);
             printf("%d", patrones[contadorNumeros1][contadorNumeros2]);
             contadorElementos++;
         }
         
         fscanf(fichero, "%f", &salidaDeseada[contadorPatron]);
         printf("\n%.2f\n", salidaDeseada[contadorPatron]);
         
         contadorNumeros1++;
     }
     //Se cierra el archivo
     fclose(fichero);
}

void primerosPesos()
{
     int x;
     time_t t;
     
     sleep(5000);
     system("CLS");
         
     srand((unsigned) time(&t));
     printf ("Pesos\n\n");
     for (x = 0; x < contadorElementos; x++)
     {
         pesos [x] = rand() % 201;
         if (pesos[x] <= 100)
         {
            pesos [x] = pesos[x] / -100;             
         }else
         {
            pesos [x] = pesos[x] / 200;
         }
         printf("w%d = %.2f\n", x, pesos[x]);
     }    
}

void recalcularPesos(int y, int bandera)
    {
         int x, z;
         float n = 0.1;
         
         printf("Los nuevos pesos son: \n");
         for(x = 0; x < contadorElementos; x++)
         {
               if (bandera == 1){
                           pesos[x] = pesos[x] + n * patrones [y] [x];
               }
               if (bandera == 0){
                           pesos[x] = pesos[x] - n * patrones [y] [x];
               }
               printf("w%d = %.2f\n", x + 1, pesos[x]);
         }
         printf("\n\n");
    }

void funcionPropagacion()
    {
         int x, y, umbral = 0, malclasificados = 0, bandera1;
         
         printf ("\nCalculando funcion de propagacion y salida del Perceptron\n\n");  
               
               for (x = 0; x < contadorPatrones; x++)
               {
                   FP [x] = 0;
               }
               
               for (x = 0; x < contadorPatrones; x++)
               {
                 printf ("FP%d = ", x + 1);
                 for (y = 0; y < contadorElementos; y++)
                 {
                     FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                     printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                 }
                 printf ("= %.2f\n", FP[x]);
                 
                 if(FP [x] > umbral)
                 {
                       SP[x] = 1;
                 }
                 else{
                      SP[x] = -1;
                 }
                 printf ("SP%d = %d\n", x + 1, SP[x]);
                 if (salidaDeseada [x] != SP[x])
                 {
                       malclasificados = malclasificados + 1;
                 }
             }
             printf ("Los mal clasificados son %d\n", malclasificados);
             sleep(5000);
             while(malclasificados > 0)
             {
                                   system("CLS");
                                   malclasificados = 0;
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                       FP [x] = 0;
                                   }
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                     printf ("FP%d = ", x + 1);
                                     for (y = 0; y < contadorElementos; y++)
                                     {
                                         FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                                         printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                                     }
                                     printf ("= %.2f\n", FP[x]);
                                     
                                     if(FP [x] > umbral)
                                     {
                                           SP[x] = 1;
                                     }
                                     else{
                                          SP[x] = -1;
                                     }
                                     printf ("SP%d = %d\n", x + 1, SP[x]);
                                     if (salidaDeseada [x] != SP[x])
                                     {
                                           printf("\nLos valores son distintos se recalcularan los pesos...\n");
                                           system("CLS");
                                           if (SP[x] < salidaDeseada [x])
                                           {
                                                     bandera1 = 1;
                                           }else{
                                                     bandera1 = 0;
                                           }
                                           recalcularPesos(x, bandera1);
                                           malclasificados = malclasificados + 1;
                                     }
                                 }
               }                       
    
         printf ("\nLas salidas son las deseadas!\n\n");
         printf ("Los pesos son:\n");
         for (x = 0; x < contadorElementos; x++)
         {
             printf ("w%d = %.2f\n", x + 1, pesos[x]);
         }
}

int main()
{
  leerArchivo();
  primerosPesos();
  funcionPropagacion();
  system("PAUSE");	
}   


Espero que le sirva a alguien, saludos.  :)
#76
C / C++ / Perceptrón en C
Marzo 29, 2016, 04:23:26 PM
Buenas, les quiero compartir este código que recién hice, se trata de un perceptrón hecho en C, en mi caso analiza 20 patrones con 64 elementos cada uno (más el primer elemento por default siendo 65), todo lo leo de un archivo .txt lo almaceno en arreglos y realizo las operaciones, para los que no saben que es un perceptrón es un método para comparar patrones que pueden ser linealmente separables, esto verifica que cierto patrón coincida con un valor, en mi caso debe coincidir con las salidas deseadas de mi .txt, en fin les dejo el código:

Código: text
#include <stdio.h>
#include <stdlib.h>

//Declaración de variables globales
char numeroPatron[20][2];
int patrones[20][65];
float salidaDeseada[20];
float pesos[65];
int contadorElementos, contadorPatrones;
float FP[20];
int SP [20];

//Paso 1 se lee el archivo que contiene los patrones
void leerArchivo()
{
     int contadorPatron, contadorNumeros1, contadorNumeros2;
     
     contadorNumeros1 = 0;
     
     printf("Los patrones son: \n");
     
     //Se declara un apuntador al archivo
     FILE * fichero;
     //Se abre el archivo para lectura con "r"
     fichero = fopen ("patrones.txt", "r");
     
     contadorPatrones = 0;
     for (contadorPatron = 0; contadorPatron < 20; contadorPatron++)
     {
         contadorElementos = 1;
         contadorPatrones++;
         //Se lee el valor del documento y se guarda en el arreglo
         fscanf(fichero, "%s", &numeroPatron[contadorPatron]);
         printf("%s\n", numeroPatron[contadorPatron]);
         patrones [contadorNumeros1][0] = 1;
         printf("%d", patrones[contadorNumeros1][0]);
         
         for (contadorNumeros2 = 1; contadorNumeros2 < 65; contadorNumeros2++)
         {
             fscanf(fichero, "%d", &patrones[contadorNumeros1][contadorNumeros2]);
             printf("%d", patrones[contadorNumeros1][contadorNumeros2]);
             contadorElementos++;
         }
         
         fscanf(fichero, "%f", &salidaDeseada[contadorPatron]);
         printf("\n%.2f\n", salidaDeseada[contadorPatron]);
         
         contadorNumeros1++;
     }
     //Se cierra el archivo
     fclose(fichero);
}

void primerosPesos()
{
     int x;
     time_t t;
     
     sleep(5000);
     system("CLS");
         
     srand((unsigned) time(&t));
     printf ("Pesos\n\n");
     for (x = 0; x < contadorElementos; x++)
     {
         pesos [x] = rand() % 201;
         if (pesos[x] <= 100)
         {
            pesos [x] = pesos[x] / -100;             
         }else
         {
            pesos [x] = pesos[x] / 200;
         }
         printf("w%d = %.2f\n", x, pesos[x]);
     }    
}

void recalcularPesos(int y, int bandera)
    {
         int x, z;
         float n = 0.1;
         
         printf("Los nuevos pesos son: \n");
         for(x = 0; x < contadorElementos; x++)
         {
               if (bandera == 1){
                           pesos[x] = pesos[x] + n * patrones [y] [x];
               }
               if (bandera == 0){
                           pesos[x] = pesos[x] - n * patrones [y] [x];
               }
               printf("w%d = %.2f\n", x + 1, pesos[x]);
         }
         printf("\n\n");
    }

void funcionPropagacion()
    {
         int x, y, umbral = 0, malclasificados = 0, bandera1;
         
         printf ("\nCalculando funcion de propagacion y salida del Perceptron\n\n");  
               
               for (x = 0; x < contadorPatrones; x++)
               {
                   FP [x] = 0;
               }
               
               for (x = 0; x < contadorPatrones; x++)
               {
                 printf ("FP%d = ", x + 1);
                 for (y = 0; y < contadorElementos; y++)
                 {
                     FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                     printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                 }
                 printf ("= %.2f\n", FP[x]);
                 
                 if(FP [x] > umbral)
                 {
                       SP[x] = 1;
                 }
                 else{
                      SP[x] = -1;
                 }
                 printf ("SP%d = %d\n", x + 1, SP[x]);
                 if (salidaDeseada [x] != SP[x])
                 {
                       malclasificados = malclasificados + 1;
                 }
             }
             printf ("Los mal clasificados son %d\n", malclasificados);
             sleep(5000);
             while(malclasificados > 0)
             {
                                   system("CLS");
                                   malclasificados = 0;
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                       FP [x] = 0;
                                   }
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                     printf ("FP%d = ", x + 1);
                                     for (y = 0; y < contadorElementos; y++)
                                     {
                                         FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                                         printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                                     }
                                     printf ("= %.2f\n", FP[x]);
                                     
                                     if(FP [x] > umbral)
                                     {
                                           SP[x] = 1;
                                     }
                                     else{
                                          SP[x] = -1;
                                     }
                                     printf ("SP%d = %d\n", x + 1, SP[x]);
                                     if (salidaDeseada [x] != SP[x])
                                     {
                                           printf("\nLos valores son distintos se recalcularan los pesos...\n");
                                           system("CLS");
                                           if (SP[x] < salidaDeseada [x])
                                           {
                                                     bandera1 = 1;
                                           }else{
                                                     bandera1 = 0;
                                           }
                                           recalcularPesos(x, bandera1);
                                           malclasificados = malclasificados + 1;
                                     }
                                 }
               }                       
    
         printf ("\nLas salidas son las deseadas!\n\n");
         printf ("Los pesos son:\n");
         for (x = 0; x < contadorElementos; x++)
         {
             printf ("w%d = %.2f\n", x + 1, pesos[x]);
         }
}

int main()
{
  leerArchivo();
  primerosPesos();
  funcionPropagacion();
  system("PAUSE");	
}   


Espero que le sirva a alguien, saludos.  :)
#77
C / C++ / Perceptrón en C
Marzo 29, 2016, 04:22:22 PM
Buenas, les quiero compartir este código que recién hice, se trata de un perceptrón hecho en C, en mi caso analiza 20 patrones con 64 elementos cada uno (más el primer elemento por default siendo 65), todo lo leo de un archivo .txt lo almaceno en arreglos y realizo las operaciones, para los que no saben que es un perceptrón es un método para comparar patrones que pueden ser linealmente separables, esto verifica que cierto patrón coincida con un valor, en mi caso debe coincidir con las salidas deseadas de mi .txt, en fin les dejo el código:

Código: text
#include <stdio.h>
#include <stdlib.h>

//Declaración de variables globales
char numeroPatron[20][2];
int patrones[20][65];
float salidaDeseada[20];
float pesos[65];
int contadorElementos, contadorPatrones;
float FP[20];
int SP [20];

//Paso 1 se lee el archivo que contiene los patrones
void leerArchivo()
{
     int contadorPatron, contadorNumeros1, contadorNumeros2;
     
     contadorNumeros1 = 0;
     
     printf("Los patrones son: \n");
     
     //Se declara un apuntador al archivo
     FILE * fichero;
     //Se abre el archivo para lectura con "r"
     fichero = fopen ("patrones.txt", "r");
     
     contadorPatrones = 0;
     for (contadorPatron = 0; contadorPatron < 20; contadorPatron++)
     {
         contadorElementos = 1;
         contadorPatrones++;
         //Se lee el valor del documento y se guarda en el arreglo
         fscanf(fichero, "%s", &numeroPatron[contadorPatron]);
         printf("%s\n", numeroPatron[contadorPatron]);
         patrones [contadorNumeros1][0] = 1;
         printf("%d", patrones[contadorNumeros1][0]);
         
         for (contadorNumeros2 = 1; contadorNumeros2 < 65; contadorNumeros2++)
         {
             fscanf(fichero, "%d", &patrones[contadorNumeros1][contadorNumeros2]);
             printf("%d", patrones[contadorNumeros1][contadorNumeros2]);
             contadorElementos++;
         }
         
         fscanf(fichero, "%f", &salidaDeseada[contadorPatron]);
         printf("\n%.2f\n", salidaDeseada[contadorPatron]);
         
         contadorNumeros1++;
     }
     //Se cierra el archivo
     fclose(fichero);
}

void primerosPesos()
{
     int x;
     time_t t;
     
     sleep(5000);
     system("CLS");
         
     srand((unsigned) time(&t));
     printf ("Pesos\n\n");
     for (x = 0; x < contadorElementos; x++)
     {
         pesos [x] = rand() % 201;
         if (pesos[x] <= 100)
         {
            pesos [x] = pesos[x] / -100;             
         }else
         {
            pesos [x] = pesos[x] / 200;
         }
         printf("w%d = %.2f\n", x, pesos[x]);
     }    
}

void recalcularPesos(int y, int bandera)
    {
         int x, z;
         float n = 0.1;
         
         printf("Los nuevos pesos son: \n");
         for(x = 0; x < contadorElementos; x++)
         {
               if (bandera == 1){
                           pesos[x] = pesos[x] + n * patrones [y] [x];
               }
               if (bandera == 0){
                           pesos[x] = pesos[x] - n * patrones [y] [x];
               }
               printf("w%d = %.2f\n", x + 1, pesos[x]);
         }
         printf("\n\n");
    }

void funcionPropagacion()
    {
         int x, y, umbral = 0, malclasificados = 0, bandera1;
         
         printf ("\nCalculando funcion de propagacion y salida del Perceptron\n\n");  
               
               for (x = 0; x < contadorPatrones; x++)
               {
                   FP [x] = 0;
               }
               
               for (x = 0; x < contadorPatrones; x++)
               {
                 printf ("FP%d = ", x + 1);
                 for (y = 0; y < contadorElementos; y++)
                 {
                     FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                     printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                 }
                 printf ("= %.2f\n", FP[x]);
                 
                 if(FP [x] > umbral)
                 {
                       SP[x] = 1;
                 }
                 else{
                      SP[x] = -1;
                 }
                 printf ("SP%d = %d\n", x + 1, SP[x]);
                 if (salidaDeseada [x] != SP[x])
                 {
                       malclasificados = malclasificados + 1;
                 }
             }
             printf ("Los mal clasificados son %d\n", malclasificados);
             sleep(5000);
             while(malclasificados > 0)
             {
                                   system("CLS");
                                   malclasificados = 0;
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                       FP [x] = 0;
                                   }
               
                                   for (x = 0; x < contadorPatrones; x++)
                                   {
                                     printf ("FP%d = ", x + 1);
                                     for (y = 0; y < contadorElementos; y++)
                                     {
                                         FP [x] = FP [x] + pesos [y] * patrones [x] [y];
                                         printf ("%.2f * %d + ", pesos[y], patrones [x] [y]);
                                     }
                                     printf ("= %.2f\n", FP[x]);
                                     
                                     if(FP [x] > umbral)
                                     {
                                           SP[x] = 1;
                                     }
                                     else{
                                          SP[x] = -1;
                                     }
                                     printf ("SP%d = %d\n", x + 1, SP[x]);
                                     if (salidaDeseada [x] != SP[x])
                                     {
                                           printf("\nLos valores son distintos se recalcularan los pesos...\n");
                                           system("CLS");
                                           if (SP[x] < salidaDeseada [x])
                                           {
                                                     bandera1 = 1;
                                           }else{
                                                     bandera1 = 0;
                                           }
                                           recalcularPesos(x, bandera1);
                                           malclasificados = malclasificados + 1;
                                     }
                                 }
               }                       
    
         printf ("\nLas salidas son las deseadas!\n\n");
         printf ("Los pesos son:\n");
         for (x = 0; x < contadorElementos; x++)
         {
             printf ("w%d = %.2f\n", x + 1, pesos[x]);
         }
}

int main()
{
  leerArchivo();
  primerosPesos();
  funcionPropagacion();
  system("PAUSE");	
}   


Espero que le sirva a alguien, saludos.  :)
#78
Noticias Informáticas / Los tenis Nike que se atan por sí solos ya están aquí
Marzo 17, 2016, 01:29:16 PM



Después de que Nike estuviera prometiendo por varios años la fabricación de unos tenis que se aten solos, sí como los de 'Back to the Future', hoy la compañía ha revelado de forma oficial su primer modelo.

Ya no sólo es un concepto o un prototipo, sino un producto real que podrá ser comprado por cualquier persona, ya que estará siendo fabricado en masa y llegará a diferentes mercados. Su nombre oficial es HyperAdapt 1.0.





El funcionamiento de estos tenis es cómo el que todos habíamos soñado, tan sólo nos los pondremos y sus agujetas se ajustarán automáticamente a nuestros pies. Eso sí, para tener un ajuste óptimo tendremos a nuestra disposición un par de botones con los que podremos apretar o soltar más las agujetas.

Nike adelanta que en un futuro no tan lejano, este tipo de calzado podrá ajustarse exactamente a la medida de nuestros pies tan sólo después ponérnoslo. Como decíamos, en esta primer versión, el ajuste final se tendrá que realizar de forma manual, si es que se requiere.





Lo mejor es que cualquier que haya soñado con estos tenis podrá comprarlos. No se ha revelado precio oficial, sin embargo, Nike espera iniciar su comercialización para finales de este mismo año. Esperemos que la empresa tenga pensado venderlos en México.


Fuente: You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
#79
Noticias Informáticas / ProtonMail llega con aplicación oficial a Android
Marzo 17, 2016, 01:24:14 PM



ProtonMail es un servicio de correo electrónico cifrado que hará que nuestros correos estén más seguros, la aplicación utiliza las mismas configuraciones de seguridad que las compañías más seguras del mundo.

Con una cantidad de usuarios de más de un millón registrados en su sistema de correo electrónico, es sorprendente que haya tomado tanto tiempo para tener una aplicación móvil. La aplicación utiliza una interfaz de usuario y el conjunto de características bastante básicas, con un cifrado extremo de punto a punto.

El servicio es gratuito, con la opción de realizar donaciones y es compatible con Android 4.0.3 o posterior.





Por alguna razón la aplicación se muestra incompatible con varios dispositivos, puede ser debido a un bloqueo geográfico, o un error en la compilación por parte del desarrollador, sin embargo no es ningún problema ya que se encuentra disponible para descargar su APK e instalarla en cualquier dispositivo Android compatible.

Fuente: You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
#80
Noticias Informáticas / Pronto podrás probar juegos directamente desde las búsquedas de Google
Marzo 16, 2016, 01:51:04 PM


La mayoría de las personas nos sentimos más confiados cuando probamos algo antes de comprarlo, en el caso de los juegos de las tiendas de aplicaciones a veces no es suficiente imagines o un video, Google lo sabe y está por lanzar una alternativa que cambiará todo el sistema.

Google trae la posibilidad de probar juegos de Google Play directamente desde las búsquedas de Google gracias a "app streaming", podrás buscar algún juego, dar clic en "probar" y comenzaras a jugar el mismo rápidamente desde el navegador, después aparecerá una pantalla donde podemos ir a descargarla.

El tiempo son 10 minutos lo cual es más que suficiente pasa saber si quieres saber más y comprarlo, sin duda es una excelente opción incluso porque no tienes que instalar nada en el dispositivo, todo es vía streaming.

Fuente: You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
Páginas 1 2 3 4 5 6 7