Recently, I installed the QEmu for Windows XP, but I had a problem for trying to configure the TAP interface with QEmu to communicate between host os and guest os. I has read a lot of tutorials and the problem has continued despite I follow all the steps of tutorials and articles to configure the network. The problem was the QEmu didn’t start when I has put the option ” -net tap,ifname=’…’ ” and the QEmu has returned a TAP device error message. The problem was incompatibilities between XP and QEmu. The QEmu was developed to Windos 98. Then you must use the incompatibilities tools of Windows ( property -> compatibility ). Now, it is all right.

If you want the initial steps, see:

[1] http://www.h7.dion.ne.jp/~qemu-win/TapWin32-en.html
[2] http://www.mlaureano.org/guias-e-tutoriais/configuracao-de-rede-qemu-e-windows/

Recentemente instalei o QEmu no Windows XP, porém tive um problema ao tentar configurar a interface TAP no QEmu para a comunicação entre o SO Host e SO Guest. Li vários tutoriais e , apesar de seguir todos os passos, o problema continuava. O problema era : Ao tentar executar o QEmu com a opção “… -net tap,ifname=’…’ …”, o programa não iniciava e acusava falha ao tentar acessar o dispositivo TAP. Pois bem, eis a causa do problema: imcompatibilidade. E para resolver esse problema basta utilizar a ferramenta de compatibilidade do Windows ( Propridades -> Compatibilidade -> Windows 98 ).
Caso queira saber os passos iniciais, acesse:
[1] http://www.h7.dion.ne.jp/~qemu-win/TapWin32-en.html
[2] http://www.mlaureano.org/guias-e-tutoriais/configuracao-de-rede-qemu-e-windows/

Olá!
Encontrei um artigo que fala sobre o efeito da bola. Ele fala um pouco do efeito de Magnus e Bernoulli. Quem admira Mecânica dos Fluídos vai gostar… :p

http://omnis.if.ufrj.br/~carlos/futebol.html

Hi!
I have found a article that speaks about the soccer ball curve. It also speaks about Magnus effect and Bernoulli effect. If you like Fluid Mechanic then you’ll like this article.

Efeito Magnus ( Link about Magnus effect and Bernoulli effect ) :

http://en.wikipedia.org/wiki/Magnus_effect
http://en.wikipedia.org/wiki/Bernoulli_effect

Nelinho’s shots  – it’s fantastic , fantastic…:
http://www.youtube.com/watch?v=b8UkwirffjQ
http://www.youtube.com/watch?v=2n5ZcjCjHT4&NR=1

Estive lendo, um pouco , Física das corridas. Felizmente, é possível achar a uma função para velocidade final. Consideraremos Fw ( força nas rodas obtida pelo torque do motor ), Fc ( atrito de rolamento ) e Fd ( força de arrasto ). Consideraremos o movimento no plano 2D.

<—– Fw [ Carro ] (Fd + Fc)–>

Suponhamos que Fw não é em função da velocidade nem do tempo e sabemos que Fc é constante.

Assim, temos :

Fw – Fd – Fc = ma = m(dv/dt)

Seja A = Fw – Fc e B = 1/2pACd, onde p é a dens. do ar, A é área frontal e Cd é coef. de arrasto. Sabemos que Fc = CrW, onde W é o peso ( consideraremos que é igualmente distribuido entre as rodas e suponhamos que o W é constante) e Cr é coeficiente.

Assim , temos :

A – Bv² = m ( dv/dt ) <-> dt = m ( dv / ( A – Bv² )

Então :

Integral [ dt ] ( de t0 a t ) = m . integral ( dv / ( A – Bv² ) ) ( de v0 a v )

Integrando e isolando v temos :

v = sqrt ( A / B ) . F [ ( PERIODO * sqrt (A . B ) ) / m + F ^-1 ( v0 . sqrt( B / A ))]

PERIODO = periodo da atualização dos frames em seg.

v0 = velocidade inicial

F(x) = tgh(x) , se |v| < sqrt(A/B)
ou
F(x) = cotg(x), se |v| > sqrt(A/B)

sqrt(x) = raiz quadrada de x

F ^-1 é a função inverso da F (ou seja arctgh ou arccotg ). Veja a seguir um pequeno trecho do código em Java :

    private double arctanh(double x) {
return ( (0.5) * Math.log( ( 1. + x ) / ( 1. – x ) ) ) ;
}

private double arccotg(double x) {
return Math.atan(1/x);
}

private double cotg(double x) {
return ( 1 / Math.tan(x)) ;
}

     /*
* [veloc_init] = m/s ;
* [dt] = s : PERIODO DE ATUALIZACAO
* [S] = m² : Área fronta
* [m] = kg : massa do corpo
*/
private double calculaVeloc(double F, double veloc_init, double dt, double S) {double a , b ;a = F – Cr * ( m * g ) ;
b = ( 0.5 ) * p * S * Cd ;if ( Math.abs(veloc_init) < Math.sqrt(a/b) ) {
return ( Math.sqrt(a/b) * Math.tanh( ( ( dt * Math.sqrt(a*b) )/ m )  + arctanh(veloc_init * Math.sqrt(b/a)) ) ) ;
} else {
return ( Math.sqrt(a/b) * cotg( ( ( dt * Math.sqrt(a*b) )/ m )  + arccotg(veloc_init * Math.sqrt(b/a)) ) ) ;
}}

Esse applet simula a construção de um grafo.
Uma matriz de adjacência é utilizada para representar as arestas .
Usa Java 2D

This applet simulates a construction of a graph.
A adjacent matrix is used to store the edges.
It uses Java 2D

Baixar código-fonte: download
Testar : Visualizar ( to view the applet )

O código está escrito em java e esquematiza um árvore binária de busca.

 Baixar ABBWindow.java