Tópico: Amostra de Programas - espaço dos programadores do CC

[Eleitor de Mário Oliveira]

Você pode sempre fazer um vetorzão e ir guardando lá.

Pensei nisto. Mas kct! O vetor teria que ter algumas dezenas de milhares de células.

Dezenas de milhares de células unsigned long int é menos de 2MB!!!!

Ah... mas agora eu me toquei de uma coisa. O intervalo dos Naturais que meu programa varre não necessariamente começa com 2. Eu posso varrer, por exemplo, de 222222 a 333333. Aí não adianta armazenar na memoria os primos já encontrados.

[SnowRaptor]

VocÊ pode sempre relaxar essa condição

[Suelen]

Houve uma época em que comecei a ler sobre lógica de programação e fiz uns programinhas simples em Pascal, com base nos exemplos do livro. Achei bastante interessante aprender sobre isso mas acabei me envolvendo com outras coisas e deixei a programação de lado. Quem sabe um dia eu volte a me dedicar... 

[SnowRaptor]

Tá, já não sei o que fazer.

Este programa em C pega um arquivo com duas colunas de 1.000.000 de números e calcula 10 médias. O negócio é que ele deveria pegar o módulo da primeira coluna e como depois ele só faz somas, não deveria dar negativo de jeito nenhum.

Código: [Selecionar]

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

#define NUM_PASSOS 1000000

int main(int argc, char** argv){
FILE *input, *output;
int mag[NUM_PASSOS], ene[NUM_PASSOS], L, Nmedias;
double *medias_mag, *medias_ene;
double mag_media=0, mag_stdev=0, ene_media=0, ene_stdev=0;
unsigned int  i_int, i_media;
char entrada[128], saida[256];


/* Converte os parametros de entrada em variaveis utilizaveis */
if (argc !=  5){
printf("Erro: Uso: %s  L temp Nmedias outdir\n", argv[0]);
exit(1);
}

Nmedias = atoi(argv[3]);
L = atoi(argv[1]);
sprintf(entrada, "saida%s.dat", argv[2]);
sprintf(saida, "%s/mag_x_temp_%s.dat", argv[4], argv[1]);

printf("Entrada: %s\nSaida: %s\nNmedias= %d\n L=%d\n", entrada, saida,Nmedias,L);

input = fopen(entrada, "r");
if (input == NULL){
printf("Erro: nao foi possivel ler %s para leitura\n", entrada);
exit(1);
}
output = fopen(saida, "a");
if (output == NULL){
printf("Erro: nao foi possivel ler %s para leitura\n", saida);
exit(1);
}

printf("Mallocando ...\n");
medias_mag = malloc (Nmedias * sizeof(double));
medias_ene = malloc (Nmedias * sizeof(double));

if (medias_mag == NULL){
printf("Erro: nao foi possivel alocar medias_mag\n");
exit(1);
}
if (medias_ene == NULL){
printf("Erro: nao foi possivel alocar medias_ene\n");
exit(1);
}

printf("Loop de scan...\n");
for (i_int=0; i_int < NUM_PASSOS; i_int++)
fscanf(input, "%d\t%d", &mag[i_int], &ene[i_int]);

printf("Loop de medias...\n");
for (i_int=0; i_int < Nmedias; i_int++){
medias_ene[i_int] = medias_mag[i_int] = 0;
printf("Loop de media %d...\n",i_int);
for (i_media=i_int; i_media < NUM_PASSOS; i_media+=Nmedias){
medias_mag[i_int] += mag[i_media] > 0 ? mag[i_media] : -1*mag[i_media];
medias_ene[i_int] += ene[i_media];
/*printf("%d\t%d\t%d\n", i_media, mag[i_media], ene[i_media]);*/
}
printf("\n");
medias_mag[i_int]=medias_mag[i_int]/(L*L*NUM_PASSOS/Nmedias);
medias_ene[i_int]=medias_ene[i_int]/(L*L*NUM_PASSOS/Nmedias);
mag_media+=medias_mag[i_int];
ene_media+=medias_ene[i_int];

}
mag_media/=Nmedias;
ene_media/=Nmedias;

printf("Loop de stdev...\n");
for (i_int=0; i_int < Nmedias; i_int++){
printf("%g\t%g\n", medias_mag[i_int], medias_ene[i_int]);
mag_stdev+=pow(medias_mag[i_int]-mag_media, 2);
ene_stdev+=pow(medias_ene[i_int]-ene_media, 2);
}
mag_stdev = sqrt(mag_stdev/Nmedias);
ene_stdev = sqrt(ene_stdev/Nmedias);

printf("fprintf...\n");
fprintf(output, "%s\t%g\t%g\t%g\t%g\n", argv[2], mag_media, mag_stdev, ene_media, ene_stdev);

printf("Fclose...\n");
fclose (output);
fclose (input);

printf("Free!\n");
free(medias_mag);
free(medias_ene);
return 0;
}


Para testar o programa, baixem o arquivo de dados, descompactem e arranquem as 3 primeiras linhas.

A linha de comando pra rodar seria (não esqueça do ponto no final)

Código: [Selecionar]

executavel.exe 50 0.7 10 .

A saída que ele gera é

Código: [Selecionar]

0.7 -1.39275 4.4415e-07 -2.78544 1.76823e-06
mas os números da segunda coluna deveriam estar entre zero e um (positivo).

Cansei de debugar e fiquei sem idéias. Sugestões?

[Eleitor de Mário Oliveira]

Cansei de debugar e fiquei sem idéias. Sugestões?

if (saida<0){saida=saida*-1;}

Acho que isto resolve.

[SnowRaptor]

Código: [Selecionar]

medias_mag[i_int] += mag[i_media] > 0 ? mag[i_media] : -1*mag[i_media];

Já tá aí o que vc sugeriu.

Não posso multiplicar a saída final arbitrariamente, porque pra outras séries de dados funciona.

[Eleitor de Mário Oliveira]

Código: [Selecionar]

medias_mag[i_int] += mag[i_media] > 0 ? mag[i_media] : -1*mag[i_media];

Já tá aí o que vc sugeriu.

Não posso multiplicar a saída final arbitrariamente, porque pra outras séries de dados funciona.

Talvez você tenha pensado o problema para uma série de dados mais específica. Seria o caso de você repensar todo problema.

[SnowRaptor]

Pode ser. Por hora, vou debugar o script que chama esse programa pra ver se ele tá passando os parâmetros certos.

[Eleitor de Mário Oliveira]

Snow, se não é para dar negativo, por que não declara a variável como unsigned?

[SnowRaptor]

Porque se eu mando um número negativo pra uma variável unsigned, ela vai lá pros quintos dos infernos, por causa da artimética de complemento de 2. Acho que mandar vaalor negativo pra variável unsigned é comportamento não definido e isso significa probabilidade 1 de o programa errar a conta (2 + 2 = 16377) e isso eu quero menos que um número negativo.

[SnowRaptor]

Pelo caso em que a saída deu errado, e capaz de eu estar mandando um argumento errado na linha de comando, porque os resultados com L = 10, 20, 30 e 40 deram certo.

[Andre]

Existe alguma biblioteca para C que baixe um arquivo da internet (via HTTP)? Eu sei que em python há um módulo para isso, mas eu preferia que fosse em C mesmo.

[SnowRaptor]

Precisa existir.

Olhei o código-fonte do wget e contrei dois arquivos: http.c e http.h

Talvez eles o ajudem. Use the force, read the source

[Andre]

Eu dei uma olhada no source dele já, mas achei que seria algo mais simples. Vou estudá-lo com mais calma.

[Andre]

Ah, mais simples ainda. Eu abro um pipe com popen() e executo "wget -O - -q <url>"

[SnowRaptor]

Sim, mas isso depende da existência do wget instalado no sistema. Achei que vc nào quisesse depender disso.

[Andre]

Eu queria só um jeito fácil de abrir um arquivo em um programa e com o pipe acho que é o jeito mais fácil. Valeu pela ajuda de qualquer forma.

Este "programa" faz o mesmo que "wget -O - www.google.com > google.html":

Código: [Selecionar]

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

int main(int argc, char *argv[])
{
FILE *input, *output;
char str[256];

input = popen("wget -O - -q 'www.google.com'", "r");
if(input==NULL)
return -1;

output = fopen("google.html", "w");
if(output==NULL)
return -1;

while(fgets(str, 255, input) != NULL)
{
fprintf(output,"%s",str);
}

pclose(input);
fclose(output);

return 0;
}

[Tash]

Teoricamente, se você pode abrir conexões com socket você pode fazer um GET direto.. basta escrever isso no socket:

Código: [Selecionar]

GET /search?q=2girls1cup HTTP/1.1
Host: www.google.com


Tem que haver um \r\n (carriage return + line feed) no final. Depois você lê a resposta, que deve ser o cabeçalho de resposta + o fonte da página.

[SnowRaptor]

Pô, Tash, podia ter pelo menos colocado um rickroll em vez disso...

Bom, se pode usar wget, a solução do pipe é boa.

Agora, tem algum jeito de fazer, em C, matrizes cujos elementos são 1 bit? Eu consigo fazer matrizes cujos elementos são 1 byte, mas só preciso de 1bit e tá chato. (Sim, existe a possibiliade de eu ter de guardar mais de 1 giga elementos de matriz.)

[Andre]

Bom, existem os bitfields. O problema é que os compiladores colocam um espaçamento nas structs, então não adianta muita coisa, em termos de memória.

Código: [Selecionar]

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

struct bits {
unsigned field1 :1;
};

int main(int argc, char* argv[])
{
printf("%u\n", sizeof(struct bits));

return 0;
}


Código: [Selecionar]

$ gcc -Wpadded -o ../bin/bitfield bitfield.c
bitfield.c:6: warning: padding struct size to alignment boundary
$ ../bin/bitfield                 
4


[Andre]

SnowRaptor, você ainda precisa de um jeito de fazer isso? Foi meio chatinho mas eu consegui usar um unsigned int como um array de 32 bits.

edit: aí usando um array de ints daria para guardar o 1GB de elementos, embora eu reconheça que seja "meio" POG.

Código: [Selecionar]

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

void print_binary(unsigned int array);
void set_bit(unsigned int *array, unsigned int position, unsigned int value);
unsigned int get_bit(unsigned int array, unsigned int position);

int main(int argc, char *argv[])
{
  unsigned int bits[4];
  int count = 0;

  for(count = 0; count < 128; count ++)
  {
    if(count % 3 == 0 || count % 5 == 0 )
    {
      set_bit(&bits[count/32], count % 32, 1);
    } else {
      set_bit(&bits[count/32], count % 32, 0);
    }
  }

  for(count = 0; count < 4; count++)
  {
    print_binary(bits[count]);
  }

  return(0);
}

void print_binary(unsigned int array)
{
  char str[33];
  int count = 0;

  for(count = 0; count < 32; count++)
  {
    if(get_bit(array, count) == 1)
    {
      str[31-count] = '1';
    } else {
      str[31-count] = '0';
    }
  }

  str[32] = '\0';

  puts(str);
}

void set_bit(unsigned int *array, unsigned int position, unsigned int value)
{
  unsigned int mask, tmp;

  /* 4294967295 == 11111111 11111111 11111111 11111111*/
  mask = ~(4294967295 & (1 << position));

  tmp = (*array & mask) + (value << position);

  *array = tmp;
}

unsigned int get_bit(unsigned int array, unsigned int position)
{
  unsigned int mask, value;

  mask = 4294967295 & (1 << position);

  value = (array & mask) >> position;

  return(value);
}

[SnowRaptor]

Que coisa coxa!

Bom, no fim das contas, pensei em implementar uma lista ligada que teria somente as coordenadas dos sítios com o valor igual a '1', mas me embananei demais na recursão e na limpeza, então desencanei. O seminário foi terça passada

[CyberLizard]

  Ressuscitando o tópico só para mostrar um joguinho de Pong que fiz para Linux aproveitando minhas férias:



Dá para fazer download do código-fonte dele aqui:

http://www.inf.ufpr.br/tla06/alien_pong.tar.bz2

[Buckaroo Banzai]

Vocês também sentem a estranha necessidade de programar nem que seja um simples hello world quando estão sem nada para fazer?

Afirmativo!

Já eu não sei programar, e quando quero resolver uma coisa, não consigo... estava tentando bolar um script para baixar podcasts de acordo com as marcações do google reader e ir tocando automaticamente, um seguido do outro, mas ainda não consegui nem "logar" no google com scripts em bash...  :'(

[SnowRaptor]

http://google-opensource.blogspot.com/2010/06/introducing-google-command-line-tool.html