Arquivos

Arquivo para a categoria ‘Computer Science’

Extendendo Python com C/C++ via PyBindGen e CTypes

sábado, 5 nov 2011; \44\UTC\UTC\k 44 6 comentários

Depois de um tempo sem postar no Ars Physica vim postar sobre algo totalmente diferente do que eu costumo escrever por aqui: programação. Como grande parte dos físicos hoje em dia, meu dia-a-dia consiste em grande parte em escrever programas de computador para resolver problemas e fazer cálculos. Todo começo de projeto de programação impõe um dilema para quem vai dedicar as próximas semanas (ou meses, anos…) escrevendo uma nova ferramenta: que linguagem de programação usar? Eu escolhi a combinação de C/C++ e Python.

As razões para essa escolha são muitas: Python é uma linguagem bastante simples, que permite prototipagem rápida e desenvolvimento de soluções com pouca dor de cabeça, e com uma ampla gama de módulos e bibliotecas prontas para os mais diversos fins (numpy, scipy, matplotlib, entre centenas de outras…). Entretanto código escrito puramente em Python é extremamente lento, por diversas razões. Isso faz com que não seja possível escrever uma simulação em python puro se pretende-se ter resultado em um tempo razoável. O ideal portanto é usar como cavalo de carga uma outra linguagem, que seja capaz de produzir binários eficientes, que rodem rápido no seu computador. Essa linguagem deve ser usada nas partes onde eficiência e tempo de execução são críticos, enquanto o Python pode ser usado para lidar com partes que geralmente são chatas de se fazer nessas linguagens de mais baixo nível: lidar com strings, arquivos, operações de sistema, geração de código, parsing,…

Como exemplo, no meu atual projeto no doutorado eu uso C/C++ para fazer uma simulação de Monte Carlo, e o Python para organizar as simulações, rodar a simulação para diversos valores de parâmetros diferentes, salvar os resultados em arquivos organizadinhos, enviar os processos para rodar nos diversos nós do cluster do departamento, etc.

Existem dezenas de formas de integrar Python com outras linguagens, de C/C++ e Fortran até Haskell e Emacs Lisp. Entretanto até hoje eu usava a mais boba: compilava um programa em C ou C++ que aceitava parâmetros de linha de comando, e de dentro do código do python abria um pipe para chamar o executável C com os parâmetros adequados com uma chamada de sistema. É uma gambiarra que funciona, mas não deixa de ser uma gambiarra. O ideal é compilar o seu código como uma biblioteca compartilhada que exporta objetos que o interpretador do Python consegue ler. A forma padrão de fazer isso é importar o cabeçalho ‘Python.h’ e usar o API contido lá para criar esses objetos. Isso não é exatamente difícil de fazer, mas é um trabalho sacal e bem repetitivo. É bom ter formas de automatizar esse trabalho e apenas se preocupar em escrever bem seu código em C, sem se preocupar se ele vai ser ou não carregado no python depois.

CTypes

Se o seu código é em C (e não C++) a maneira mais fácil de fazer isso é usando o CTypes – um módulo presente na biblioteca padrão do Python capaz de carregar bibliotecas compartilhadas feitas em C. Por exemplo, suponha que você deseja criar uma função que some dois inteiros e retorne o resultado. O código fonte está nos arquivos teste.h e teste.c:

//arquivo: teste.h
int add(int x, int y);

//arquivo: teste.c
#include "teste.h"
int add(int x, int y){
  return (x + y);
}

Note que esse é um código em C “vanilla”, sem nenhuma referência ao fato de que ele será depois usado no Python. Tudo o que é preciso para disponibilizar a função ‘add’ no python é compilar esse código como uma biblioteca compartilhada:

gcc -fPIC -o libteste.o -c teste.c
gcc -shared -o libteste.so libteste.o

Isso deve gerar um arquivo ‘libteste.so’, que é um binário que possui as instruções da função ‘int add(int, int)’ de forma que pode ser acessado por outros binários em C. Para chamar esse binário dentro do Python com o CTypes é muito fácil:

from ctypes import cdll

libteste = cdll.LoadLibrary("./libteste.so")
# eh necessario passar o caminho completo para o binario pois ele nao esta no PYTHONPATH
x = libteste.add(5, 2)
print x

Esse script deve retornar o valor ’7′, conforme esperado. Difícil, né?

Quando sua função retorna um tipo que não seja ‘int’, é necessário ainda informar ao Python qual é o tipo adequado para converter os objetos do python antes de passá-los para a função em C. O CTypes oferece uma gama de tipos correspondentes a todos os tipos que podem ser criados em C padrão:

Tipo no CType Tipo no C Tipo no Python
c_bool _Bool bool (1)
c_char char 1-character string
c_uint unsigned int int/long
c_long long int/long
c_float float float
c_double double float
c_char_p char * (NUL terminated) string or None

Por exemplo, considere a seguinte função:

//arquivo: teste.h
double c_raizq(double x);

//arquivo: teste.c
#include <math.h>
#include "teste.h"

double c_raizq(double x){
  return sqrt(x);
}

Nesse caso, ao abrir a biblioteca (compilada exatamente como antes) será necessário dar mais informação a respeito dos tipos dessa função:

from ctypes import cdll
from ctypes import *

libtest = cdll.LoadLibrary("./libtest.so")
raiz = libtest.c_raizq
raiz.restype  = c_double
raiz.argtypes = [c_double]

x = raiz(2)

print x

Toda função importada do C tem as duas propriedades ‘restype’ – que é o tipo que a função deve retornar – e ‘argtypes’ – que é uma lista dos tipos que essa função recebe como parâmetros, na ordem em que eles aparecem no código em C.

Quando for necessário usar ponteiros, arrays, structs ou enums, a coisa pode ficar um pouquinho mais complicada, mas nada que faça o código crescer muito mais do que isso. Por exemplo, suponha que queremos exportar o seguinte código para o Python:

//arquivo: teste.h

struct cvec{
  double x;
  double y;
};

typedef struct cvec vector;
double norm(vector * point);  

//arquivo: teste.c

#include "teste.h"
#include <math.h>

double norm(vector * point){
  return sqrt(point->x * point->x + point->y * point->y);
}

Precisamos de uma estrutura similar ao struct ‘vector’ e de portar a função ‘norm’. Note que o argumento dessa função é um ponteiro para a struct vector. O código Python para fazer isso segue abaixo:

from ctypes import cdll
from ctypes import *

#imitando a struct vector 
class vector(Structure):
    _fields_ = [("x", c_double) ,
                ("y", c_double)]

libtest = cdll.LoadLibrary("./libtest.so")
norm = libtest.norm
norm.restype  = c_double
norm.argtypes = [POINTER(vector)]

vecc = vector(5,2)
print norm(pointer(vecc))

A classe vector imita a estrutura do struct vector, e as funções POINTER e pointer são usadas respectivamente para informar que o tipo do argumento é um ponteiro e obter um ponteiro para o objeto ‘vecc’. Structs e unions deve ser replicadas no Python por classes que herdam das superclasses Structure e Union, respectivamente.

Enfim, o CTypes fornece um API completo para usar qualquer código C padrão dentro do Python com um mínimo de boilerplate e nenhuma interferência no código original. Não é preciso reescrever suas funções nem entender a estrutura do API do Python. Apenas compilar seu código como uma biblioteca compartilhada.

PyBindGen

Infelizmente o CTypes não é capaz de ler binários de C++. A razão é simples: não existe um padrão para os binários de C++ e cada compilador implementa interfaces diferentes para seus binários. A esperança é que com o estabelecimento do padrão C++11 isso possa ser resolvido, mas isso é uma questão para o futuro. No entanto existe uma biblioteca feita em Python capaz de gerar bindings de códigos em C++ sem interferir no código e com o mínimo de esforço. Por exemplo, suponha que temos uma classe feita em C++ que representa pontos em 2 dimensões, com alguns métodos úteis:

//arquivo Vector.hpp
#include <cmath>
class Vector {
private:
  double x;
  double y;
public:
  Vector(double _x, double _y) : x(_x), y(_y) {}; //construtor

  double norm();               // retorna tamanho do vector
  void reflectO();           // reflete o vetor através da origem
  void rotate(double theta); // roda o vetor em torno da origem por um angulo theta
};

//arquivo Vector.cpp
#include "Vector.hpp"

double Vector::norm() {
  return x*x + y*y;
}

void Vector::reflectO(){
  x = -x;
  y = -y;x
}

void Vector::rotate(double theta){
  double xx = cos(theta) * x - sin(theta) * y;
  double yy = sin(theta) * x + cos(theta) * y;
  x = xx;
  y = yy;
}

Essa classe cria um vetor com duas componentes, com métodos que calculam a norma, refletem o vetor através da origem e rodam por um certo angulo. Para tornar essa classe disponível para o Python é preciso criar um script que gera automaticamente os bindings que devem ser então compilados em um módulo. A estrutura do script é bem simples – primeiro você deve criar um módulo e adicionar ao módulo a classe que deseja exportar, e em seguida adicionar os métodos à classe:

#arquivo: setupBinding.py
#! /usr/bin/env python

import sys
import pybindgen
from pybindgen import param, retval

#Modulo Vector
mod = pybindgen.Module("Vector")

#o modulo inclui o header Vector.hpp
mod.add_include('"Vector.hpp"')

#Adicionando a classe:
klass = mod.add_class('Vector')

#Adicionando o construtor:
klass.add_constructor([param('double', '_x'), param('double', '_y')])

#Adicionando os metodos:
klass.add_method('norm', retval('double'), [])
klass.add_method('reflectO', None, [])
klass.add_method('rotate'  , None, [param('double', 'theta')])

#imprime o binding na tela
mod.generate(sys.stdout)

Note a sintaxe dos comandos:

  • add_constructor([param('tipo', 'nome'),…]) – essa função recebe uma lista com os parametros que o construtor recebe. Se houver mais de um construtor, eles devem ser todos adicionados em sequencia.
  • add_method(‘nome’, retval(‘tipo de retorno’), [param('tipo_do_parametro1', 'nome1'), …]) – essa função recebe o nome do método, o tipo do valor que o método retorna e uma lista com os tipos dos parametros de entrada.

Ao rodar esse script com ‘python setupBinding.py’, ele imprime na tela um código em C que é um binding para o código contido em ‘Vector.cpp’ e ‘Vector.hpp’. Ao compilar esses bindings, teremos um módulo Vector que pode ser importado dentro do python como qualquer outro módulo:

import Vector

foo = Vector.Vector(1,2)
print foo.norm()
foo.rotate(0.2)

Compilar esse módulo é só um pouquinho mais complicado do que no caso do CTypes. Em primeiro lugar é preciso compilar uma biblioteca compartilhada como anteriormente:

g++ -fPIC -c -o libvector.o  Vector.cpp
g++ -shared  -o libvector.so libvector.o

sh Isso cria os arquivos ‘libvector.o’ e ‘libvector.so’. E então devemos gerar os bindings:

python setupBinding.py > bindVector.c

sh E compilar uma biblioteca compartilhada com os bindings:

g++ -fPIC -I/usr/include/python2.7 -c -o bindVector.o bindVector.c
g++ -shared -o Vector.so -L. -lvector bindVector.o

Note que é preciso passar para o compilador o caminho para os headers do python no seu sistema – no meu caso a versão 2.7 do python no linux está em ‘usr/include/python2.7‘. Também é preciso passar para o linker o caminho atual, onde está os arquivos ‘libvector.so’ e ‘libvector.o’ – que é a pasta atual onde a compilação está sendo feita. Isso é feito com as flag “-L. -lvector”. Isso cria o arquivo Vector.so, que contém o módulo Python que pode ser carregado através do comando “import”. Note que o nome do arquivo deve ser o mesmo nome do módulo conforme adicionado no script que gerou os bindings.

Antes de tentar importar o arquivo no python, é preciso adicionar o caminho onde o arquivo ‘Vector.so’ se encontra nas variáveis de ambiente PYTHONPATH e LD_LIBRARY_PATH:

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:.
export PYTHONPATH=$PYTHONPATH:.

Agora o módulo Vector pode ser usado normalmente:

import Vector

foo = Vector.Vector(1,2)
print foo.norm()
foo.rotate(0.2)

Enfim. Espero que isso ajude quem, como eu, vem quebrando a cabeça com isso a muito tempo e já testou diversas ferramentas (SWIG, SIP, Cython/Pyrex, Boost::Python, etc, etc, etc… ). As documentações oficiais das ferramentas usadas nesse post podem ser encontradas aqui:

Reconstrução 3D via fotos…

sábado, 27 nov 2010; \47\UTC\UTC\k 47 Deixe um comentário

Só pra animar um pouco esse sábado cinzento daqui, aqui vai uma notícia bem legal: 3-D mashup of Rome from Flickr pics.

Ou seja, fizeram uma reconstrução 3D — de monumentos em cidades como Roma e Berlim — a partir de fotos disponíveis publicamente (e.g., Flickr e Google Images). Tecnologia sensacional! :twisted:

[N.B.: Versão no Twitter.]

SciBloWriMo…

segunda-feira, 8 nov 2010; \45\UTC\UTC\k 45 1 comentário

O mês de Novembro é conhecido no meio literário como NaNoWriMo, National Novel Writing Month.

Um pessoal da Matemática decidiu pegar carona nessa idéia de criar o MaBlogWriMo: Math Blog Writing Month. A idéia, como descrita no link, é a de se escrever todo dia um post com até 1.000 palavras sobre matemática. :cool:

Então, parafraseando ambos esses eventos, vou começar o SciBloWriMo: Science Blog Writing Month! :twisted:

Eu vou aproveitar que vou dar uma palestra na conferência Miami 2010 e pegar uma carona pra falar dum tema que eu já venho trabalhando há algum tempo: o espaço de soluções (aka moduli space) de teorias quânticas de campo e suas simetrias. Esse será um dos temas do SciBloWriMo aqui no AP.

O outro tema é o de um trabalho que eu venho realizando atualmente, em colaboração com um pessoal da Neurociência, sobre o funcionamento hierárquico e maçissamente paralelo do cérebro, chamado Ersätz-Brain.

Assim que os posts forem ficando prontos, eu os linko aqui,

  • Álgebra, Teoria da Representação e Picard-Lefschetz;
  • Neurociência e o Projeto Ersätz-Brain: Teoria de Gauge, Variáveis de Nós e o Funcionamento Hierárquico do Cérebro.

É isso aí: espero que ninguém esteja com medo do frio! :wink:

Semantic Web: Web 3.0…

domingo, 16 mai 2010; \19\UTC\UTC\k 19 Deixe um comentário

Quem quiser ver um pouco mais sobre o assunto,

O mais incrível disso tudo é que a idéia original do TBL sempre foi essa: usar metadata pra “organizar” e “concatenar” a informação. Entretanto, infelizmente, apenas agora (quantas décadas depois da “invenção” da web? :razz: ) a idéia original está sendo apreciada como se deve.

Cálculo Exterior para Elementos Finitos…

sábado, 6 mar 2010; \09\UTC\UTC\k 09 Deixe um comentário

ResearchBlogging.org

O artigo Finite element exterior calculus: from Hodge theory to numerical stability trata dum tópico que eu gosto muito: análise numérica feita com ferramentas modernas (e.g., Cohomologia de de Rham e Teoria de Hodge).

Meu interesse sobre esse tipo de tópico começou cedo, quando na graduação eu comecei a lidar com problemas numéricos. A noção de que a estabilidade e convergência do método numérico deveria variar com a particular discretização (“mesh”) escolhida sempre ficou atrás da minha orelha. Mas, naquelas épocas, ainda estando na graduação, pouco era possível se fazer. Mas a vontade de aplicar essas idéias em Lattice Gauge Theory sempre me provocou. :wink:

Um pouco mais tarde, já na pós (mestrado), eu trombei com alguns artigos interessantes que, novamente, morderam essa mesma pulguinha,

Meu interesse por esses artigos era claro: o esquema de discretização deles tenta preservar as simetrias de Lie do problema original. Isso é particularmente importante se o objetivo é simular problemas que envolvem Quebra de Simetria! :idea: :cool:

Um pouco de tempo depois… me aparece o seguinte artigo, A Discrete Exterior Calculus and Electromagnetic Theory on a Lattice; que, mais tarde, seria seguido pelos seguintes artigos: Discrete Differential Geometry on Causal Graphs e Differential Geometry in Computational Electromagnetics.

A idéia, então, era novamente clara: aplicar esse mecanismo de Cálculo Exterior Discreto em Teorias de Gauge! :idea: :cool:

Afinal de contas, quem sabe, não daria pra juntar ambas as idéias: usar Cálculo Exterior Discreto de forma a preservar as simetrias [de Lie] do problema no contínuo :!: O que será que poderia sair daí?! (De fato, não tenho a menor noção, infelizmente nunca tive tempo de voltar e morder essa questão. Mas, taí um problema prum doutorado… :wink: )

Bom, depois de tudo isso, aparece o artigo que motivou esse post — eu tinha que falar alguma coisa a respeito dele.

Na verdade, esse artigo vai mais longe, extendendo o trabalho feito anteriormente, definindo apropriadamente uma Teoria de Hodge para Elementos Finitos, e avaliando as conseqüências para a consistência (“well-posedness of the Cauchy problem”; algo que varia muito com as particularidades da questão em mãos) e estabilidade numérica do problema. Portanto, as técnicas disponíveis agora são muito mais robustas! (O que só me deixa cada vez mais curioso pra saber a resposta das questões acima… :wink: )

É isso aí: a leitura é excelente, a diversão é garantida… e eu não me responsabilizo por noites de sono perdidas (por causa das questões acima)! :twisted:

Referências

  • Arnold, D., Falk, R., & Winther, R. (2010). Finite element exterior calculus: from Hodge theory to numerical stability Bulletin of the American Mathematical Society, 47 (2), 281-354 DOI: 10.1090/S0273-0979-10-01278-4

As melhores ferramentas de colaboração online…

quarta-feira, 17 fev 2010; \07\UTC\UTC\k 07 Deixe um comentário

Eu trombei no Mind Map abaixo, que faz uma lista (com recomendações quando necessário) das melhores ferramentas de colaboração online de 2009, e achei que vcs pudessem gostar e aproveitar também. :wink:

Best Online Collaboration Tools 2009; by Robin Good

Best Online Collaboration Tools 2009

(Versão PDF da imagem acima: Best Online Collaboration Tools 2009, by Robin Good (PDF, 220Kb).)

Quem tiver mais dicas, ou achar que faltou alguma coisa no MindMap acima… é só mandar pau nos comentários! :twisted:

Google Public DNS…

quinta-feira, 3 dez 2009; \49\UTC\UTC\k 49 Deixe um comentário

Hoje o Google pôs no ar um serviço de DNS,

A TechCrunch tem alguns comentários em Google Gets Into The DNS Business. Here’s What That Means; e o LifeHacker também tem alguns comentários, Google Public DNS Aims to Speed Up Your Browsing [DNS].

Vale a pena dar uma testada: os benchmarks que eu fiz por aqui foram bastante positivos. (E, claro, eu me empolguei um pouco… :wink: )

Fora isso, uma notícia um tanto inusitada, também vindo do Google,

Ou seja, os caras preferem evitar contratações “em massa”, pra garantir o bom equilíbrio do “ecossistema” chamado “mercado”. :cool:

Atualizado (2009-Dec-03 @ 14:26h): Agora o Slashdot está dando a notícia também, Google Launches Public DNS Resolver. (Sim, estou repassando esta notícia em tempo real! :twisted: )

E pra quem estiver interessado em dar uma “tunada” no próprio site, eis outra diquinha,

Diversão garantida… :cool:

O realejo do dia…

quinta-feira, 8 out 2009; \41\UTC\UTC\k 41 Deixe um comentário

Pra quem ainda não conhece, o Google Flu trends (“Google Gripe”) acabou de ser expandido de 4 para 22 países. Nos EUA, os dados do Google Flu têm 92% de correlação com os dados do Governo (estes últimos podem demorar até 2 semanas pra serem disponibilizados ao público; ao passo que o GFlu é mais “tempo real”).

Aí vai um videozinho explicando como o GFlu funciona,

Pronto… agora todo mundo pode relaxar e comprar seu terno anti-gripe suína (H1N1) predileto! :roll: :razz:

Enquanto isso, há “boatos” (i.e., artigos ainda não publicados) se propagando dizendo que a vacina contra a gripe “normal” pode aumentar os riscos de se contrair a gripe suína — dêm uma olhada em Flu Roundup.

Flame war garantidíssimo! :twisted:

A semana nos arXivs…

sexta-feira, 25 set 2009; \39\UTC\UTC\k 39 Deixe um comentário


Gödel, Escher, Bach…

sábado, 20 jun 2009; \25\UTC\UTC\k 25 1 comentário

Quem nunca ouviu falar do excelente livro Gödel, Escher, Bach: An Eternal Golden Braid (ver também Gödel, Escher, Bach; By Douglas R. Hofstadter)?

Pois bem, o MIT OCW tem um curso inteiro baseado no livro, MIT OCW: GEB. E os vídeos podem ser encontrados aqui, GEB: Video Lectures.

Diversão garantida! :twisted:

Opera 10 beta passa no Acid3…

quarta-feira, 3 jun 2009; \23\UTC\UTC\k 23 Deixe um comentário

Como eu falei do chromium num post anterior, nada mais justo do que falar do novo Opera 10 (beta): Além de melhoras significativas na velocidade e suporte aos padrões do W3C, o novo ‘engine’ passa nos testes Acid3 (olha só a fotinha abaixo)! :twisted:

Acid3 no Opera 10 (beta) — MacOS X (10.5.7)

Acid3 no Opera 10 (beta) — MacOS X (10.5.7)

Diversão garantida! :twisted:

Compilando o Chromium no Mac…

terça-feira, 2 jun 2009; \23\UTC\UTC\k 23 1 comentário

Como eu tinha pouca coisa pra ler ontem — :shock: :roll: —, decidi testar minhas habilidades ‘compiladorísticas’ e ver se conseguia compilar o Chromium no Mac.

Como vcs devem saber, ainda não há um ‘build’ do Google Chrome nem pra GNU/Linux nem pro Mac OS X. Mas, usando o código open-source do Chrome (chamado Chromium), é possível simplesmente se compilar o danado e ver no que dá. No caso do Mac, basta seguir as instruções em MacBuildInstructions. E foi exatamente o que eu fiz. O resultado vcs podem ver abaixo… :twisted:

Google Chromium no Mac OS X (10.5.7)

Google Chromium no Mac OS X (10.5.7)

P.S.: Claro, ainda há alguns problemas, como falta de suporte a UTF-8, plugins, etc. Mas, a estabilidade e velocidade do bixinho é uma surpresa agradável. :wink:

Atualizado (2009-Jun-02 @ 17:23h): Chrome For Mac “Coming Along Fine”. :wink:

Atualizado (2009-Jun-05 @ 15:52h): O time de desenvolvedores do Chromium lancou, ontem, a versao alpha do “Chrome” para Mac e GNU/Linux: Chromium Releases Official Mac, Linux Browser Alphas. Pra quem esta acompanhando esse post, isso nao faz a menor diferenca, uma vez que as versoes compiladas ‘no muque’ ja sao mais atualizadas que esse lancamento. :wink:

Google Wave…

sexta-feira, 29 mai 2009; \22\UTC\UTC\k 22 4 comentários

Como eu ainda não vi essa notícia sendo divulgada em nenhuma mídia brasileira… decidi quebrar o silêncio e informar, em primeiríssma mão, o próximo lançamento do Google: Google Wave! (Veja detalhes mais técnicos em Wave Protocol.)

Segundo quem já assistiu ao vídeo abaixo, Google Wave é tudo aquilo que o email seria se tivesse sido inventado atualmente — ou seja, a coisa promete! :-) Em poucas palavras, o GWave é uma plataforma colaborativa onde se pode compartilhar documentos e “conversas”, i.e., as pessoas podem se comunicar compartilhando arquivos (rich text format), fotos, mapas, vídeos, etc. Isso sem falar que a “wave” (‘onda’) é algo completamente compartilhado e em tempo real!

De fato, a coisa promete… Diversão garantidíssima! :twisted:

Atualizado (2009-May-29 @ 18:37h EDT): O T. Tao também pegou essa notícia, e ficou tão ansioso quanto esse que vos fala: Google Wave.

Revolução do grafeno dá mais um passo

quinta-feira, 30 abr 2009; \18\UTC\UTC\k 18 1 comentário

Fotografia obtida por microscópico eletrônico de varredura do circuito integrado nanométrico construido a base de grafeno. As barras amarelas são eletrodos de cromo e ouro e sobre a superfície azul ligando os eletrodos há uma fina camada de grafeno.

Fotografia obtida por microscópico eletrônico de varredura do circuito integrado nanométrico construido a base de grafeno. As barras amarelas são eletrodos de cromo e ouro e sobre a superfície azul ligando os eletrodos há uma fina camada de grafeno. Figura do artigo original de R. Sordan et al.

Físicos na Itália desenvolveram o primeiro circuito integrado de grafeno, o relatório foi publicado semana passada no arxiv.

O grafeno é um nanomaterial descoberto em 2004 que consiste em uma folha bidimensional de átomos de carbono de apenas um único átomo de espessura (uma fatia atômica de grafite). Ele difere dos demais materiais semicondutores — que são os materiais com as propriedades eletrônicas adequadas para construção de diodos e transitores — por manter alta mobilidade dos elétrons mesmo quando dopado com alta densidade de impurezas. Isso reflete em uma resistência a corrente elétrica que está entre as mais baixas já encontradas em um material a temperatura e pressão atmosférica, tornando o grafeno uma potencial matéria-prima para construção de circuitos integrados de alta freqüência (acima de GHz) em escalas micrométricas de tamanho, o que pode vir a substituir a presente tecnologia dos semicondutores de silício utilizados nos computadores e eletrônicos modernos. O trabalho do grupo italiano é um passo importante nessa direção porque demonstra que estes circuitos são factíveis. Em 2007, um grupo de Harvard já havia construído o primeiro transistor de grafeno.

Para saber mais:

  1. Fledgling graphene circuit performs basic logic, Physics World.
  2. Graphene na Wikipedia.

Diquinha tecnológica…

quarta-feira, 1 abr 2009; \14\UTC\UTC\k 14 4 comentários

Tirando o fato de que hoje é “1º de Abril” e que ter um “piloto automático no GMail” — :lol: — seria certamente fantástico… o Google anunciou outra coisa ainda melhor: a liberação da função “labs” do GMail para todos os idiomas que o Google suporta.

Isso é sensacional: havia alguns empecilhos técnicos pra liberar o “Labs”, mas agora a coisa tá liberada. Pra quem usa o GMail, então, aí vai uma listinha das funções do “Labs” que eu curto (os nomes estão em inglês porque eu ainda não vi a versão em pt_BR): Offline; Tasks; YouTube, Picasa, Flickr, Yelp Previews; Superstars; Pictures in Chat; Fixed Width Font; Custom date Formats; Advanced IMAP controls; Canned responses; Default “Reply to All”; Quote Selected Text; Navbar Drag’n Drop; Forgotten Attachment Detector; Custom Label Colors; Mark as Read Button; Go to Label; Create a Document; Filter import/export; Text messaging (SMS) in chat; Send & Archive; Undo Send; Location in Signature; Title Tweaks, Add a gadget by URL.

Pra quem curte a interface do GMail e gosta de trabalhar nesse esquema “Web2.0″ — e usa o Firefox :razz: —, eu recomendo os seguintes “complementos” (essa é a tradução oficial de “add-ons”; fazer o quê :razz: ): BetterGMail2, Remember the Milk (GMail gadget, GCalendar gadget e Offilne Access) e GTDInbox… e Xoopit também! :smile:

E pra quem quer dar um passo adiante e tentar algo ainda mais sexy… Install Linux In Your Dropbox Account Using VirtualBox.

Diversão garantidíssima!

:twisted:

Os melhores livros de divulgação

domingo, 29 mar 2009; \13\UTC\UTC\k 13 29 comentários

Que tal uma lista de utilidade pública com alguns dos melhores livros de divulgação? :)

Bom, naturalmente que a lista será parcial. Vai ser baseada na experiência pessoal dos editores do blog, mas a vantagem é que você pode usá-la como ponto de partida se quer algumas sugestões de leitura leve para as férias, ou então se você gostou de alguns dos livros da lista, há potencial de gostar dos demais. :) Volte sempre para checar atualizações na lista! ;)

Não vamos tentar fazer uma resenha de cada livro que ficaria muito longo, você pode ver essas resenhas por ai na Internet, no site das editoras e livrarias. Ah, e a lista não tem nenhuma ordem em especial, certo?

Vamos lá:

Disponível em português:

  • A Dança do Universo, Marcelo Gleiser
  • DNA: O Segredo da Vida, James D. Watson
  • Uma breve história do tempo, Stephen W. Hawking
  • Como a mente funciona, Steven Pinker
  • A falsa medida do homem, Stephen Jay Gould
  • O mundo assombrado pelos demônios, Carl Sagan
  • QED: A Estranha Teoria da Luz e da Matéria, Richard P. Feynman
  • O que é uma lei física?, Richard P. Feynman
  • Einstein para principiantes, Joseph Schwartz, Michael McGuinness
  • Os Três Primeiros Minutos, Steven Weinberg
  • O Universo Inflacionário, Alan H. Guth
  • Será que Deus joga dados?, Ian Stewart
  • O Quark e o Jaguar, Murray Gell-Mann
  • As aventuras e descobertas de Darwin a bordo do Beagle, Richard Darwin Keynes
  • O que é Matemática?, Richard Courant e Herbert Robbins
  • O último teorema de Fermat, Simon Singh
  • História da Matemática, Carl Boyer, Uta C. Merzbacher. Não é divulgação, mas é excelente e acessível.
  • História química de uma vela, Michael Faraday
  • Cronologia das ciências e das descobertas, Isaac Asimov
  • A Filha de Galileu, Dave Sobel

Apenas em inglês:
Estes você pode comprar na Amazon.com, ou na Barnes & Noble. Você só pagará o livro, frete e a taxa de câmbio. Não há imposto cobrado de importação para livros.

  • Huygens & Barrow, Newton & Hooke, Vladimir I. Arnold
  • From Galileo to Einstein (aka Biography of Physics), George Gamow
  • Longing for the Harmonies, Frank Wilczek e Betsy Devine
  • Black Holes and Time Warps, Kip Thorne
  • Men of Mathematics, E. T. Bell
  • Einstein’s Legacy, Julian Schwinger
  • Gravity, George Gamow
  • Cosmology: The Science of the Universe, E. Harrison

Matemática na era da Web2.0…

quarta-feira, 25 fev 2009; \09\UTC\UTC\k 09 3 comentários

A WWW daria uma lousa e tanto… se a gente conseguisse rabiscar uma equação

A WWW foi concebida no CERN e, desde então, o patamar em que chegamos atualmente (chamado de Web 2.0) é bem diferente daquilo que se imaginava na época da criação da Web. Hoje em dia já se fala em Web 3.0, que é uma espécie de codinome para Cloud Computing. Porém, o sonho original para a WWW é a chamada Semantic Web. Eis o próprio T.B. Lee falando sobre esse assunto,

De fato, a tal “Web 3.0″ deve incluir toda essa parte “semântica” (veja mais em W3C Semantic Web Activity, The Semantic Web e The Semantic Web Revisited (PDF)), chamada tecnicamente de Metadata — apesar de que a incorporação de todos esses “metadados” em bancos-de-dados e aplicações (“cloud”) afins ainda vai levar algum tempo. :wink:

De qualquer maneira… essa “simples” idéia — de assimilar os “metadados” de forma fundamental e intrínseca nas entranhas da Web — tem um enorme potencial quando o assunto é Publicação Científica. Um exemplo claro disso é o Scientific Publishing Task Force: Mindswap: Science and the Semantic Web, Science and the Semantic Web (PDF), Semantic web in science: how to build it, how to use it, ScienceOnline09: The Semantic Web in Science.

Então, como se pode ver com clareza, essa idéia de se associar “semântica” aos elementos já pertencentes da WWW, realmente será algo revolucionário.

A razão pra essa longa introdução é o paradigma adotado pelo MathML, que é a linguagem que permitirá a introdução de linguagem Matemática na WWW. Existem dois modos de se “descrever” uma informação em MathML, Presentation MathML e Content MathML — enquanto o pMathML foca na apresentação e aparência das equações e elementos matemáticos, o cMathML foca no significado semântico das expressões (num esquema bem parecido com Cálculo λ :cool: ).

Então, fica claro que o objetivo de MathML não é apenas o de “apresentar” uma informação, mas também de dar significado semântico a ela, o que fará com que a comunicação matemática seja muito superior do que a comunicação atual, feita em HTML!

O paradigma atual: \TeX

Hoje em dia, efetivamente, quem tem necessidade de publicar muitas equações usa \TeX, mais especificamente, usa-se \LaTeX — esse é o de facto padrão.

Essa linguagem é extremamente poderosa, versátil e flexível, podendo ser extendida de várias maneiras diferentes. E isso facilita muito sua aplicação em várias áreas diferentes: desde símbolos matemáticos, gráficos vetoriais, …, até símbolos musicais, de xadrez e tipografia em línguas gráficas, como árabe, hindu, chinês e afins!

Por essas e por outras, atualmente é muito mais comum de se encontrar programas que convertem de \TeX para MathML do que programas que nativamente facilitam a edição nativa [em MathML]. Tanto que existe um livro unicamente dedicado a esse assunto: The LaTex Web Companion. Aliás, nessa linha, eu recomendo o uso do formato DocBook, cuja saída pode ser HTML, PDF, \TeX (via o uso de XSLT), etc.

Portanto, o que acabou acontecendo é que quando alguém precisa publicar fórmulas e afins, ou se cria um documento em PDF, ou se usa de “algum desvio” para colocar a informação na Rede — em geral, esse desvio consiste em se converter o conteúdo desejado em alguma imagem, e inserí-la no HTML em questão.

A saída: habilitar os navegadores

A alternativa pra tornar tudo isso integrado (Web 3.0, MathML, etc) e unificado é prepararmos os navegadores para essa nova jornada, nova etapa, da WWW. Por exemplo, o Firefox tem toda uma infra-estrutura dedicada para MathML: MathML in Mozilla. Porém, pra isso, é preciso que os desenvolvedores de navegadores sigam os padrões já definidos para MathML. Essa é uma lista dos navegadores que suportam MathML. Além disso, pra quem usa Firefox, esse é um ‘add-on’ bem interessante, Firemath (eu não tenho uma conta com o Mozilla, então, se alguém que tiver uma conta quiser me mandar o add-on, eu agradeço :wink: ).

Portanto, o caminho ainda se encontra aberto… e as possibilidades são infinitas! :twisted:

Referências…

Computação Científica e de Alta Performance…

terça-feira, 25 nov 2008; \48\UTC\UTC\k 48 8 comentários

O termo Computação de Alta Performance (HPC na sigla em Inglês) é usado para designar um determinado tipo particular de hardware, usado para atacar problemas que demandam o máximo da máquina, como “Teorias Quânticas de Campos na Rede“, “Enovelamento de Proteínas“, “Paleoclimatologia“, etc.

Um dos primeiros “galhos” dessa árvore da HPC foi a chamada “computação voluntária“, onde um usuário comum pode doar os ciclos inativos do seu computador para cálculos científicos, e.g.:

Tecnicamente falando, o nome dessa técnica é Computação em Gride — e, atualmente, no melhor espírito da Web2.0, fala-se também em termos de Computação na Nuvem.

O resumão dessa história começa há tempos atrás, enquanto as CPUs ainda eram oficialmente divididas em 2 tipos:

E, dentre esses 2 tipos, há mais algumas subdivisões:

Isso determina, essencialmente, o tipo de CPU que vc tem… aí é hora de falar em paralelização;-)

Ou seja, a coisa fica bem complicada bem rápido… e, como se pode esperar, navegar nessas águas não é fácil… (Apesar de que o Sam Fulcomer ganhou o prêmio de ‘Ultimate HPC Geek’ desse ano!)

Historicamente falando, os problemas mais complicados sempre eram atacados com hardware que, essencialmente, era construído para o problema em questão (vários dos Cray foram construídos para o cálculo de Campos Quânticos na Rede, ditto para os BlueGene da IBM, etc)… porém, com a descoberta dos Clusters Beowulf, essa arte de se construir “supercomputadores” acabou sendo posta de lado, em favor da massificação desse tipo de clusters — aliás, numa palestra na Brown, ParalleX: A New Execution Model for Sustainable HPC Design, o Thomas Sterling (um dos inventores dos Beowulf) disse claramente que se arrependia de tê-lo feito, uma vez que aquilo que era pra ser apenas uma alternativa barata, passou a virar o foco central e, essencialmente, acabou com o desenvolvimento e pesquisa na área de supercomputação!

Um dos últimos CPUs a serem desnvolvidos ainda nesse aspecto, foi o MULTIFLOW, do qual participaram ativamente Gerry Guralnik e Jim O’Dell — o Jim, aliás, foi um dos primeiros desenvolvedores do Macsyma, no Project MAC do MIT, o precurssor dos CAS modernos.

Por isso, foi muito bom ter visto as notícia abaixo:

O primeiro deles fala do Jaguar, o primeiro computador a quebrar a barreira dos PetaFLOPS! Enquanto que o segundo artigo fala do NVIDIA Tesla, que é um supercomputador pessoal, com até 960 cores!

É inacreditável, mas depois que os clusters tomaram conta do mercado de HPC (como bem disse o Thomas, acima), a única atividade que ainda demandava uma quantidade de processamento tamanha que necessitava de processadores vetoriais era a dos gráficos dos jogos de vídeo-game! E, como era de se esperar, o crescimento e avanço desse setor impulsionou o desenvolvimento de HPC que já estava estagnado em clusters há anos. Então, do mesmo modo que a indústria pornográfica impulsionou a demanda por banda-larga e possibilitou que a Internet chegasse até cada um de nós, em nossas casas; a indústria de vídeo-games propulsionou o desenvolvimento de HPC dum modo completamente inesperado. :-)

A lição a ser aprendida é que não adianta, alguns problemas só podem ser atacados com investimento em pesquisa básica e fundamental… não dá pra querer baratear tudo, sucateando tecnologia de ponta no processo. ;-)

É isso aí: diversão garantida para o feriado! :twisted:

[]‘s.

Simulações em Cromodinâmica Quântica…

terça-feira, 18 nov 2008; \47\UTC\UTC\k 47 6 comentários

A edição desse mês da revista American Scientist (uma publicação da Sigma Xi) tem um artigo [de divulgação] muito interessante sobre Lattice QCD:

A idéia por detrás desse artigo (de divulgação) é clara: usar computadores pra fazer os cálculos pesados, que a gente não consegue fazer “no braço”. Historicamente, isso tudo surgiu na segunda metada dos anos 70, com o estabelecimento da Cromodinâmica Quântica (QCD) e com um melhor acesso aos computadores (apesar de que a programação era feita com cartões-perfurados! :wink: ).

O problema que motivou essa empreitada é dado pelo fato de que é muito difícil de se obter qualquer tipo de resultado analítico em QCD — a razão mestra disso é um fato conhecido como “acoplamento forte” — até então, o único método analítico disponível era o chamado expansão 1/N (aliás, o artigo Path Integral Formulation of Mean Field Perturbation Theory foi um dos primeiros a definir essa expansão em Teorias Quânticas de Campo). Traduzindo em miúdos, o que acontece é que quarks têm um comportamento muito exótico: chamado de confinamento, o que acontece é que quarks nunca são vistos isoladamente, i.e., “livres”, na natureza. Isso se deve ao fato de que quanto mais vc tenta separar 2 quarks, mais forte é fica a força que os une, i.e., a força entre 2 quarks aumenta com a distância! Notem como isso é completamente contra-intuitivo: todas as forças que a gente conhece (fraca, gravitação, eletromagnética) têm o comportamento exatamente oposto, ou seja, a intensidade delas diminui quando a distância aumenta (i.e., fica sempre cada vez mais fácil de se separar os 2 corpos quanto mais longe eles estiverem). Por causa desse comportamento, não é possível fazermos o mesmo tipo de “aproximações” que usamos em outras áreas da Física (e que funcionam perfeitamente bem, com até 12 casas decimais de precisão experimental!); e é pra resolver essa enrascada que a tal “aproximação 1/N” (mencionada acima) foi inventada.

Bom, o resumo dessa ópera é que uma das melhores armas pra se atacar essas questões todas é via simulações computacionais. O “truque” é que mesmo nesse caso, que já tem vários resultados positivos, é preciso se dispor de supercomputadores, como o Blue Gene ou o QCDOC — muitas das arquiteturas do Cray e da IBM foram desenvolvidas em colaboração com Físicos trabalhando em problemas de “Lattice QCD”, especialmente por causa desse necessidade monstruosa de poder de processamento que o problema demanda.

N.B.: Quem quiser se aprofundar mais, pode ler os seguintes artigos: Lattice QCD for Novices, Advanced Lattice QCD e Nonperturbative Quantum Field Theory on the Lattice. Existe um website que tenta agregar essa comunidade, The Lattice Web. Em termos de livros, os que eu recomendo são os seguintes: Introduction to Quantum Fields on a Lattice, Quantum Fields on a Lattice, Lattice Gauge Theories, Quarks, Gluons and Lattices (o autor desse livro, M. Creutz, foi um dos fundadores desse ramo da Física). Um pouco fore do “mainstream” (princpalmente por serem publicações mais antigas), mas também interessantes, são os livros de Lattice Gauge Theories and Monte Carlo Simulations e Gauge Field Theories. No Brasil, eu aprendi parte do que conheço desse assunto no grupo Lattice Quantum Field Theory (em particular, os resultados mostrados em Older Work são interessantíssimos!), e o único outro grupo que eu conheço que trabalha nessa área é Física de Partículas Computacional (IFSC-USP). (Se vc trabalha nessa área e eu não conheço a sua existência, por favor, deixe um comentário, com os links apropriados, que eu terei o maior prazer em corrigir a minha ignorância, atualizando esse artigo. :oops: )

[]‘s.

Atualizado (2008-Dez-02 @ 20:12h): Há uma continuação dessa notícia, com um pouco mais de informações, nos links abaixo (que saíram ontem):

Ambos são excelentes artigos… somados ao primeiro acima… diversão garantida!

:twisted:

[]‘s.

Seguir

Obtenha todo post novo entregue na sua caixa de entrada.

Junte-se a 66 outros seguidores

%d blogueiros gostam disto: