Aqui farei algumas anotações principalmente dicas que facilitam a vida durante minha pesquisa aqui no grupo de Sistemas Complexos do IF-UFF.
Bem, as funções mais úteis quando precisamos passar parâmetros como argumentos da linha de comando do seu programa, são as funções que convertem palavras em variáveis numéricas. Para recordar as mais intuitivas são:
int atoi(char *p)converte uma string armazenada em p num tipo int;
float atof(char *p)para converter ao tipo float;
unsigned long int strtoul(char *p, char *q, int base)novamente p é a string a ser convertida, q é a string para armazenar os caracteres desprezados na conversão, nunca precisei usar uma variável q diferente de NULL como parâmetro, pois nunca precisei armazenar nada além do parâmetro numérico e base uso geralmente a base decimal passando o valor 10, o resultado é uma variável do tipo unsigned long int;
double strtod(char *p, char *q)o mesmo raciocínio para a função acima, só que desta vez não precisamos escolher a base numérica para a dupla precisão, geralmente passo NULL no lugar de q, visto que nunca precisei estocar caracteres despresíveis na conversão.
Só para não esquecer o link, não é dica de computação, porém ajuda a manter a cuca fria.
Isso é uma tarefa árdua, sei que a tag m centraliza verticalmente, seguida de {x cm} para dimensionar a largura da coluna, então para adicionar a centralização horizontal devemos usar o \centering de uma forma não muito intuitiva. Lembrando que o pacote array é que é responsável por tudo então no preâmbulo:
\usepackage{array}
após isso nossa tabela pode ser montada,
\begin{tabular}{|>{\centering\arraybackslash}m{6cm} |>{\centering\arraybackslash}m{6cm}|} \hline \centering \textbf{Coluna 1} & \textbf{coluna 2}\\ \hline pouco texto & Aqui a gente escreve bastante coisa para percebermos que o texto ao lado está bastante centralizado, infelizmente esse também.\\ \hline só pra enrolar & Alô mundo.\\ \hline \end{tabular}Pronto, temos uma tabela perfeitamente centralizada em todos os sentidos.
P.S.: Só funcionou com as tags > e \arraybackslash posicionadas conforme mostrei acima, não me perguntem por quê.
Basta fazer:
Só porque eu esqueci o que já haviam me falado antes, então fica o lembrete:
(time ./a.out) 2> time.log 1> saida.log2 vai redirecionar a saída de time e 1 vai redirecionar a saída dos printf's dos seu programa, a saída do programa é redirecionada pro arquivo.
Para o uso da função realloc do ANSI C algum cuidado é necessário, primeiramente a dica de http://www.vivaolinux.com.br/dica/Usando-o-realloc é muito boa.
A função deve ser chamada como o valor para um ponteiro e passada como parâmetro para que os endereços de memória fiquem todos bem organizados. Isso vale se você for implementar uma função que insere um elemento numa pilha também, isto é, o que se espera da sintaxe correta para o realloc deve se esperar da sua nova função:
void *inserir(int x, int *P, int *tam) { P=(int *)realloc(P,(*tam+1)*sizeof(int)); P[*tam]=x; *tam=*tam+1; }
Essa função irá colocar o inteiro x na pilha P, previamente alocada com o espaço para um inteiro no mínimo, porém a posição da memória do ponteiro P ficará bagunçada, logo o correto será:
int *inserir(int x, int *P, int *tam) { P=(int *)realloc(P,(*tam+1)*sizeof(int)); P[*tam]=x; *tam=*tam+1; return P; }
Agora quando for inserir um inteiro num trecho do seu programa basta fazer:
Q=inserir(3,Q,&tam_Q);
e a memória RAM é o limite.
Se quiser plotar em tempo de execução basta deixar a saída do programa no formato que o gnuiplot pode ler e executar apenas
plot '<./seuprograma'.
Pronto olhe seu gráfico ao fim da execução do seu código.
Tudo bem que as bibliotecas não evoluem na mesma velocidade que o python, mas depois que fiz essa atualização ontem meu programa que usa as bibliotecas pylab e networkx não funcionaram, mesmo mudando o cabeçalho para
#!/usr/bin/python2
, se eu usasse #!/usr/bin/python
ele iria ter problemas de sintaxe e importação, visto que essas bibliotecas ainda não ganharam sua versão para python 3.
Mas o problema que eu tive foi justamente na matplotlib, que é chamada pela pylab, algumas funções de dentro dela fazem chamada para a versão 2.6 do python, quando a versão disponível no meu sistema que vive em “paz” com a versão 3 é justamente a 2.7. Logo o procedimento (gambiarra) foi fazer um link simbólico da matplotlib na pasta da versão 2.6, claro que devemos ser super-usuários para isso:
ln -s /usr/lib/python2.7/site-packages/matplotlib /usr/lib/python2.6/site-packages/matplotlib
E assim a matplotlib que não existia na pasta python2.6 passa a existir. No Debian não tive esse problema pois a versão testing não “evoluiu” ainda pro python 3, na verdade eles fizeram alguma cagada durante esse upgrade.
Ainda tenho problemas como, é necessário o uso da função show() da pylab para poder observar meus gráficos, antes no ipython -pylab eu usava apenas o comando plot(…) e pronto, o gráfico estava pronto, mas agora preciso de plot(…) e depois show() :(
Depois de uma olhada no neste bug reportado pela comunidade do Arch, me falaram que era apenas para remover o cache pessoal,
rm -r ~/.matplotlib
A GSL é a melhor biblioteca de programação científica na linguagem C. E uma das muitas utilidades dela são seus geradores de números pseudo-aleatórios. Que usei recentemente e consiste em alguns passos muito fáceis, vide documentação em http://www.gnu.org/software/gsl/manual/html_node/Random-Number-Generation.html. Que eu resumo aqui.
#include <gsl/gsl_rng.h>
gsl_rng *r;e crie o espaço na memória
r = gsl_rng_alloc(gsl_rng_tipo);onde tipo poderá ser substituído pelos nomes dos geradores disponíveis: taus, gfsr4, mt19937, ranlxs0, ranlxs1, mrg, ranlux, ranlxd1, ranlxs2, cmrg, ranlux389, ranlxd2;
gsl_rng_set(r,semente);onde semeste é uma variável do tipo
unsigned long int
gsl_rng_uniform_int(r,n);para gerar um número aleatório do tipo unsigned long int no intervalo fechado [0,n-1]. Ou se preferir
gsl_rng_uniform(r);para números no intervalo [0,1). A função mais simples é a
gsl_rng_get(r);que retorna um número aleatório, sempre do tipo inteiro longo sem sinal, entre o inteiro mínimo e máximo do tipo de gerador escolhido, e pode ser guardado para dar continuidade à mesma lista de pseudo-aleatórios do gerador utilizado.
gsl_rng_free(r);
São quatro passos mínimos:
import networkx as nx
G=nx.read_edgelist('arquivo.dat')
sG=nx.connected_component_subgraphs(G)
nx.write_edgelist(sG[0],'saida.dat')
Apenas isso, e o grafo está separado.
