A terra está crescendo? - Earth is growing?

Há algum tempo, já vinha matutando comigo que fazia algum sentido que a terra estivesse crescendo.

O afastamento dos continentes, bem como as sucessivas camadas de terra em qualquer terreno, arqueológico ou não, incitam nossa imaginação nesse sentido.

Além disso, temos o fato da energia não se perde, e recebemos luz do sol (energia) todo dia. Diz a teoria que energia é proporcional à massa, então, se retemos energia do sol, de alguma forma isso deve ser transformada em massa.

Ao longo do tempo, seja pela fotossíntese, ou outro processo qualquer, ou mesmo por vários processos distintos, paulatinamente a energia recebida do sol diariamente seria acumulada na terra, gerando um aumento de massa (e volume).

Suspeito até que o volume de água na terra esteja crescendo ao longo do tempo, já que nada me prova que os oceanos eram naturalmente grandes há bilhões de anos. Parte da energia recebida do sol estaria sendo transformada em água. Não há explicação científica convincente de como a 'poeira de estrela' ou seja, a nuvem de gás que era originalmente a terra se transforma em uma outra matéria (atómo).

O caminho para entender o crescimento da terra é entender como ocorre essa transformação da luz em matéria.

Somente após pensar em escrever este mini-artigo, procurei na internet e achei informações sobre gente que já tinha teoria semelhante.


O melhor artigo que encontrei sobre o tema está em http://en.wikipedia.org/wiki/Expanding_Earth (em inglês).

Há uma coleção de  vídeos de um dos defensores, que pode ser encontrado em:

http://www.nealadams.com/nmu.html


--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

10 dicas para um marketing mais estratégico

http://br.hsmglobal.com/notas/56342-10-dicas-um-marketing-mais-estrategico?utm_source=120210_marketing&utm_medium=120210_marketing&utm_content=120210_marketing_10-dicas-um-marketing-mais-estrategico&utm_campaign=120210_marketing
--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

Adeus ao Windows - Agora só Linux

8 anos depois de começar a mexer com Linux, finalmente posso abandonar o Windows por completo.

A última desculpa que eu tinha eram os jogos, e agora, finalmente, consegui rodar o Pro Cycling Manager no Linux.

Como é meu jogo preferido, e os outros não importam tanto, estou pronto para a mudança.

Windows, bye, bye.


O processo para configurar o PCM 2009 no Linux foi relativamente simples:

1. Instalar o PlayOnLinux
2. Instalar o PCM manualmente, criando um novo wineprefix.
3. Instalar o Directx, editando o prefixo do wine.
4. Instalar o NetFramework, editando o prefixo do wine
5. Instalar o patch 1.0.3.3 do PCM
6. Finalmente, tive que crackear (colocar os arquivos do crack), apesar de meu jogo ser original. (o wine não consegue instalar os drivers de restrição do patch do  PCM)

Agora, outros jogos, só se forem emulados ou forem para Linux. :-)



--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

como configurar web2py e php no mesmo servidor (debian ou ubuntu)

Observação: embora no mesmo servidor, eles usarão domínios ou subdomínios diferentes (virtualhosts)



O primeiro passo é instalar o web2py com o script setup_web2py.sh, no link abaixo:

http://www.megaupload.com/?d=48Y3TQ9C

ele já foi alterado para incluir o postgresql 8.4


# sudo setup_web2py.sh


o segundo passo é instalar o php:

#apt-get install. libapache2-mod-php5


(e outras dependências que quiser)


O último passo é incluir um novo virtualhost no apache. (

a) crie um arquivo com o nome do seu domínio/subdomínio e coloque em /etc/apache2/sites-enabled:

b) coloque o conteúdo abaixo, alterando apenas o servername :

-------------------------------------------

<VirtualHost *:80>
ServerName php.mydomain.com
#ServerAlias


ServerAdmin webmaster@localhost

DocumentRoot /var/www
<Directory />
Options FollowSymLinks
AllowOverride None
</Directory>
<Directory /var/www/>
Options Indexes FollowSymLinks MultiViews
AllowOverride None
Order allow,deny
allow from all
</Directory>

ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
<Directory "/usr/lib/cgi-bin">
AllowOverride None
Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
Order allow,deny
Allow from all
</Directory>

ErrorLog /var/log/apache2/error.log

# Possible values include: debug, info, notice, warn, error, crit,
# alert, emerg.
LogLevel warn

CustomLog /var/log/apache2/access.log combined

Alias /doc/ "/usr/share/doc/"
<Directory "/usr/share/doc/">
Options Indexes MultiViews FollowSymLinks
AllowOverride None
Order deny,allow
Deny from all
Allow from 127.0.0.0/255.0.0.0 ::1/128
</Directory>

</VirtualHost>
---------------------------------------------------------------------------------

É só reiniciar o apache e pronto:

# sudo service apache2 restart


--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

Scaffolding para Code Igniter

Estou pensando em usar Code Igniter como base nos novos projetos que tiver que fazer em php, embora minha preferência pelo web2py/python, e a notícia de um scaffolding para o CI me interessou:

http://blog.relaxos.com.br/php/ci-scaffold-gerador-de-crud-para-code-igniter/

O link para baixar o scaffold é

http://code.google.com/p/ci-scaffold/

--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

Modal windows com Jquery

Algumas informações básicas para mexer com janelas com Jquery

http://dev.iceburg.net/jquery/jqModal/

 

http://www.tidbits.com.br/click-modal-plugin-de-jquery-para-fazer-modal-lightbox

 

http://docs.jquery.com/Ajax

 

http://jquery.malsup.com/form/

--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

Raspagem de dados

Um interessante artigo sobre raspagem de dados, algo que mais cedo ou mais tarde todos precisaremos.
Afinal, de certa forma já usamos, porque qualquer buscador da web (leia-se google, bing, yahoo) utiliza-se deste recurso.

http://imasters.uol.com.br/artigo/15447/bancodedados/raspagem_de_dados/


--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

Novo RG: cadastro deve começar em janeiro

Fonte: http://pcworld.uol.com.br/noticias/2009/12/30/novo-rg-cadastro-deve-comecar-em-janeiro/

Documento terá microchip e dados gravados a laser. Um dos objetivos do governo é evitar falsificações.

O ano de 2010 deve começar com mudanças nos documentos dos brasileiros. O Instituto Nacional de Identificação (INI), órgão ligado à Polícia Federal, espera que nos próximos dias seja publicado o decreto para implementação do novo Registro de Identidade Civil (RIC).

O documento vai reunir os números de todos os documentos de registro dos cidadãos, como CPF, Carteira de Trabalho, Carteira Nacional de Habilitação e Título de Eleitor – além do Registro Geral. Com a publicação do decreto, a expectativa é de que o cadastro para a emissão das novas carteiras de identidade comece em janeiro.

Ao solicitar o RIC, o cidadão passará pelos procedimentos habituais para obter a carteira de identidade, com coleta de digitais, fornecimento de dados pessoais e assinatura. A diferença, segundo a Polícia Federal, é que o processo será totalmente informatizado, garantindo um cadastro nacional biométrico.

O novo cartão terá um sistema complexo de tecnologia que inclui microchip e dados gravados a laser no documento. O objetivo é evitar falsificações e permitir maior agilidade na transmissão de dados sobre uma pessoa em todo o território nacional. Os órgãos regionais deverão receber estações de coleta e transferir os dados para o órgão central em Brasília, que por sua vez emitirá a nova identidade.

Espera-se que a partir do terceiro ano de implementação do projeto 80 mil pessoas possam ser cadastradas por dia, alcançando a meta de 20 milhões de cidadãos por ano. Em nove anos, cerca de 150 milhões de brasileiros devem ter o novo RIC.

--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

Go Horse Process e variantes

O blog Go Horse Process apresenta de um modo irônico, uma crítica ao gerenciamento de projetos nas organizações, com um toque hora mais cômico, hora mais lúcido.

É leitura recomendada para qualquer pessoa que trabalhe, mas especialmente para quem lida com desenvolvimento de software.

--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

algoritmo para encontrar melhor rota

do blog viva o linux:
http://www.vivaolinux.com.br/script/Algoritmo-genetico-rotas

############################################################
#ALGORITMO GENETICO DESENVOLVIDO PARA DISCIPLINA INTELIGENCIA ARTIFICIAL   #
#OBJETIVO: SOLUCAO EFICIENTE PARA O PROBLEMA DE ROTEAMENTO DE VEICULOS     #
#AUTOR: CESAR TINUM ,SABRINE HENRIQUE           DATA:06-11-2009                           #
#CENTRO UNIVERSITARIO DE BELO HORIZONTE DCE -       7 PERIODO MANHA                  #
#CONTATO :             magodoschatsbh@gmail.com , sabrine@2xt.com.br                           #
############################################################


#SELECAO     #MUTACAO   #CROSSOVER
import random                                 #GERACAO NUMEROS ALEATORIOS
from threading import Thread               #BIBLIOTECA DE GERACAO DE SUBPROCESSOS (THREADS)
from math import ceil                        #BIBLIOTECA DE ARREDONDAMENTO NUMERICO
from time import time, strftime
class AG:
   def __init__(self, mutacao,crossover,tamPopulacao,fitnes, cidades, maxdistancia, geracoes, numthreads, naoalcanco):
      start = time()
      self.MAX_DIST = maxdistancia
      self.mutacao = mutacao                      #propriedade de mutacao
      self.crossover = crossover
      self.NAOALCANCO = naoalcanco            #possibilidade de nao haver caminho entre cidades
      self.tamPopulacao = tamPopulacao          #numero populacao inicial
      self.fitnes = fitnes                           #funcao de avaliacao
      self.populacao = []                           #vetor contendo a populacao
      self.fitPopulacao = []                        #vetor com resultado avaliacao de cada elem da populacao
      self.distancia = {}
      self.NUM_THREADS = numthreads
      self.geracoes = geracoes
      self. cidades = cidades
      self.disCidades(cidades)
      self.populacaoInicial = []
      self.__initGeracao()
      self.selecao()
      self.populacaoInicial = self.populacao
      for i in range(self.geracoes):
         self.__nextGeracao()
         self.__crossover()
      self.selecao()
      finish = time()
      self.time = finish - start
      self.__header()
   #FIM CLASSE INICIALIZACAO
   def __initGeracao(self):
      try:
         threads = []
         for i in range(self.NUM_THREADS):
            threads.append(self.__startThreads('self.geraPopulacao', {}))                                 #DISPARANDO THREADS PARA GERAR POPULACAO E AVALIACAO DOS ELEMENTOS
         self.__endThreads(threads)                                                                                 #ESPERA THREADS ACABAREM
      except Exception, e:
         print e
   def __nextGeracao(self):
      try:
         threads = []
         tamMutacao = round(ceil(float(self.tamPopulacao) / 2)* self.mutacao)                                          #NUMERO DE INDIVIDUOS QUE SOFRERAO MUTACAO
         faixa = int(ceil(tamMutacao / self.NUM_THREADS))
         r = int((tamMutacao>self.NUM_THREADS and self.NUM_THREADS or tamMutacao))                     #VERIFICA SE NUM THREADS E MAIOR QUE NUM ELEMENTOS QUE SOFRERAO MUTACAO
         for i in range(r):
            threads.append(self.__startThreads('self.geraMutacao', {'ini':i+1, 'tam':faixa}))            #DISPARANDO THREADS PARA EFETUAR MUTACAO NOS PIORES ELEMENTOS DA POPULACAO EM FAIXAS
         self.__endThreads(threads)                                                                                    #ESPERA THREADS ACABAREM
      except Exception, e:
         print e
   def __endThreads(self, threads):
      for t in threads:
         t.join(10)
      return
      
   def geraMutacao(self,ini,  tam):
      try:
         sorteados = []                                                                                    #GUARDA ELEMENTOS SORTEADOS PARA QUE O ALGORITMO NAO ENTRE EM LOOP SORTEANDO SEMPRE O MESMO NODO
         tamC = self.tamPopulacao
         ini = tamC - (2*ini)
         flag = True
         limite = ini + tam
         numCidades = len(self.cidades)
         while ini <= limite:
            tenhoCidades = True
            if flag:
               cont = 0
               posCorte = random.randint(3, numCidades -1)                                                                     #PONTO DE CORTE PARA MUTACAO ALEATORIO
               n = numCidades-posCorte                                                                                             #NUMERO DE ELEMENTOS QUE SERAO TROCADOS
               list = self.populacao[ini][2:posCorte]
               del self.populacao[ini][posCorte:]                                                                                       #DELETO O RESTO DO VETOR A PARTIR DO PONTO DE CORTE PARA INSERIR NOVOS ELEMENTOS
               sorteados = []
               i = 0
               j = 0
            while tenhoCidades:
               flag = False
               nodo = self.cidades[random.randint(0, numCidades-1)]
               if  cont > numCidades - 1:
                  flag = True
                  break
               if nodo in sorteados or nodo in list:
                  cont+=1
                  continue
               try:
                  if self.populacao[ini][posCorte - 1]:
                     d = (self.adjacencia(nodo, self.populacao[ini][posCorte-1])  and True or None)
                  else:
                     d = True
               except Exception, e:
                  d = None
               if d:
                  self.populacao[ini].append(nodo)
                  list.append(nodo)
                  res = self.geraFitnes(self.populacao[ini], 2)
                  self.populacao[ini][0] = res[0]
                  self.populacao[ini][1] = res[1]
                  i+=1
               tenhoCidades = not self.__sublist(list, self.cidades)
            if not flag:
               ini+=1
         return True
      except Exception, e:
         return False
   def __startThreads(self, funcAlvo, k):
      try:
         t = Thread(target = eval(funcAlvo), kwargs = k)
         t.start()
         return t
      except Exception, e:
         print  e
   def disCidades(self, cidades):                                                               #GERA DISTANCIA ENTRE CIDADES , MATRIZ DE ADJACENCIA
      for i in cidades:
         self.distancia[i] = {}
         for j in cidades:
            if  not self.distancia[i].has_key(j):                                                    #SE J NAO ESTA NO DICIONARIO DA CIDADE I VOU INCLUI-LA
               if self.distancia.has_key(j) and j!=i:                                                #SE CIDADE J ESTA NO DICIONARIO (JA TENHO VALOR) E J!=I (NAO E A MESMA CIDADE)
                  self.distancia[i][j] = self.distancia[j][i]
                  continue
               if i == j:
                  self.distancia[i][j] = 0
                  continue
               alcanco = random.randint(1, self.NAOALCANCO)               #CHANCE DE CIDADES NAO SE ALCANCAREM = 1 EM NAO ALCANCO (PARAMETRO)
               if alcanco == 1:
                  self.distancia[i][j] = 100000                                    #ATRIBUI VALOR DISTANCIA MUITO ALTO = CIDADE NAO ALCANCAVEL
                  continue
               self.distancia[i][j] = random.randint(1, self.MAX_DIST)   #SORTEIA VALOR DA DISTANCIA ALEATORIAMENTE ENTRE 1 - MAX_DIST SE FOR A MESMA CIDADE VALOR DISTANCIA 0
      return
   def selecao(self):                                                                              #DIVIDIR A POPULACAO EM GRUPOS PARA APLICAR FUNCAO DE AVALIACAO POR THREADS.
      self.populacao.sort()
   def geraPopulacao(self):
      tam = int(ceil(float(self.tamPopulacao)/4))
      try:
         for i in range(tam):
            d = []
            sorteados = []
            d.append(self.cidades[random.randint(0, len(self.cidades) - 1)])                                                                                                               #1 CIDADE ALEATORIA
            sorteados.append(d[0])
            cont = 1
            while not self.__sublist(d, self.cidades):                                                                                                #RODA LOOP ENQUANTO NAO TEM TODAS CIDADES NA ROTA - SE IMPASSE ATE 100 ITERACOES - COMECA DE NOVO
               b = self.cidades[random.randint(0, len(self.cidades) - 1)]
               cont+=1
               if cont >len(self.cidades):
                  cont = 0
                  d = []
                  sorteados = []
                  d.append(self.cidades[random.randint(0, len(self.cidades) - 1)])                                                                                                               #1 CIDADE ALEATORIA
                  sorteados.append(d[0])
               elif b in sorteados:
                  continue
               sorteados.append(b)
               c = (self.adjacencia(d[len(d)-1],b) and d.append(b) or False)                                                #VERIFICA SE CIDADES SAO ADJACENTES (EXISTE ROTA ENTRE ELAS)
            if len(self.populacao) == self.tamPopulacao:                                                                     #COMO AS THREADS PODEM SE DIVIDIR EM MAIS ELEMENTOS QUE O TAMANHO ORIGINAL PRAMETRIZADO
               return False                                                                                                         #DEVIDO AO ARREDONDAMENTO DE VEZES PARA CADA THREAD CRIAR ELEMENTOS
            res = self.geraFitnes(d, 0)                                                                                          #VERIFICO AQUI SE TAMANHO TOTAL DE ELEMENTOS JA FOI CRIADO ANTES SE INSERIR CADA ELEMENTO
            d.insert(0, res[0])
            d.insert(1, res[1])
            self.populacao.append(d)
         return True
      except Exception, e:
         print e

   def adjacencia(self, a, b):
      return ((self.distancia[a][b]<9999 and a!=b or False) and True or False)            #SE A DISTANCIA MENOR QUE 9999 AVALIA SE A!=B PARA EVITAR IR E VOLTAR NA MESMA CIDADE
   def geraFitnes(self, mat, pos):                                                                   #AVALIA CADA ROTA POSSIVEL DA POPULACAO
      try:
         d = []
         e = mat[pos:]
         mat = mat[pos:]
         f = self.cidades
         tenhoTodasCidades = ((self.__sublist(mat, f) and True or False) and 1 or 100)                     #VERIFICA SE ROTA SENDO AVALIADA POSSUI TODAS AS CIDADES
         d.extend(self.distancia[mat[i]][mat[i+1]] for i in range(len(mat)))            
         return [tenhoTodasCidades, sum(d)]                                                   #SOMA VALOR DE DISTANCIA ENTRE CIDADES DA ROTA
      except Exception, e:
         return [tenhoTodasCidades, sum(d)]
   def load(self, url):
      try:
         file = open(url, 'r')
         fileLines= file.readlines()
         for linha in fileLines:
            linha = linha.split(" ")
            for indice, distancia in enumerate(linha):
               pass
         #LE CADA LINHA E ATRIBUI VALOR DE DISTANCIAS   
      except Exception, e:
         print e
   def __sublist(self, filho,  mae):
      try:
         contem=[]
         contem.extend((item in filho and 1 or 0) for item in mae)                              #VERIFICA SE ROTA POSSUI TODAS CIDADES
         if 0 in contem:
            return False
         else:
            return True
      except Exception, e:
         print 'Erro na busca de sublista, ', e
   def __crossover(self):                                                                           #IMENDA ROTAS MAIS BEM AVALIADAS EM ROTAS MAL AVALIADAS A PARTIR DE PONTO EM COMUM
      try:
         tamCrossOver = round(ceil(self.tamPopulacao / 2)* self.crossover)                                          #NUMERO DE INDIVIDUOS QUE SOFRERAO MUTACAO
         faixa = int(ceil(tamCrossOver / self.NUM_THREADS))
         r = int((tamCrossOver>self.NUM_THREADS and self.NUM_THREADS or tamCrossOver))                     #VERIFICA SE NUM THREADS E MAIOR QUE NUM ELEMENTOS QUE SOFRERAO MUTACAO
         threads = []
         for i in range(r):
            threads.append(self.__startThreads('self.geraCrossOver', {'ini':i+1, 'tam':faixa}))            #DISPARANDO THREADS PARA EFETUAR MUTACAO NOS PIORES ELEMENTOS DA POPULACAO EM FAIXAS
         self.__endThreads(threads)
      except Exception, e:
         print e
   def geraCrossOver(self, ini, tam, nodo=None):
      try:
         tamC = self.tamPopulacao
         ini = tamC - (tam*ini)
         flag = True
         limite = ini + tam
         numCidades = len(self.cidades)
         melhorRota = self.populacao[0][2:]                     #AS CIDADES DA MELHOR ROTA, 2 EM DIANTE POS 0 E 1 SAO AVALIACOES
         while ini < limite:
            if limite>=self.tamPopulacao:
               break
            while nodo == None:
               posCorte = random.randint(3, len(self.cidades)-1)                                                      #PONTO DE CORTE ONDE SERA FEITO A JUNCAO
               nodo = (lambda nodo: nodo in melhorRota and nodo or None)(self.populacao[ini][posCorte])
            del self.populacao[ini][:2]                                                                                    #RETIRA VALORES AVALIACAO
            v = {len(self.populacao[ini][:self.populacao[ini].index(nodo)]):'esq', len(self.populacao[ini][self.populacao[ini].index(nodo):])-1:'dir'}         #NUMERO DE ELEMENTOS A DIREITA E ESQUERD DA POSICAO DE CORTE
            g = {len(melhorRota[:melhorRota.index(nodo)]):'esq', len(melhorRota[melhorRota.index(nodo):])-1:'dir'}         #NUMERO DE ELEMENTOS A DIREITA E ESQUERD DA POSICAO DE CORTE DA MELHOR ROTA
            ladoV = max(v.items())                                                                                    #CRUZAR O LADO QUE TIVER MAIOR NUMERO DE ELEMENTOS [0] = LADO [1] = NUM ELEM
            ladoG = max(g.items())                                                                           #CRUZAR O LADO QUE TIVER MAIOR NUMERO DE ELEMENTOS [0] = LADO [1] = NUM ELEM
            cont=0
            c=0
            ######################################################   
            #VALIDAR NUM ELEMENTOS EQUIPARANDO AO VETOR BASE ( MELHOR ROTA)
            ######################################################   
            if ladoG[0]<ladoV[0]:
               ladoV = min(v.items())                                                                           #MANTER O LADO DO MELHOR VETOR COMO MAIOR PARA NAO FALTAR INDICE
            indiceNodo = self.populacao[ini].index(nodo)
            indiceNodoG = melhorRota.index(nodo)
            if ladoV[1] == 'esq':
               try:
                  if indiceNodo>0:
                     del self.populacao[ini][:indiceNodo-1]                                                   #DELETA ELEMENTOS A ESQUERDA DO INICIO ATE O INDICE DO VETOR DE JUNCAO
                  indiceNodo = (indiceNodo > 0 and (indiceNodo - 1))
                  for indice in range(indiceNodo):
                     indiceNodoG = (ladoG[1] == 'dir' and (indiceNodoG +1) or (indiceNodoG -1))
                     self.populacao[ini].insert(indice, melhorRota[indiceNodoG])                        #ADICIONANDO ELEMENTOS A DIREITA NO VETOR DE MELHOR ROTA
               except Exception, e:
                  pass
            else:
               try:
                  indiceNodo = self.populacao[ini].index(nodo)
                  if indiceNodo<len(self.populacao[ini])-1:
                     del self.populacao[ini][indiceNodo+1:]                                                   #DELETA ELEMENTOS A ESQUERDA DO INICIO ATE O INDICE DO VETOR DE JUNCAO
                  indices = []
                  ind = indiceNodo
                  id = len(self.cidades) - indiceNodo
                  while len(indices)  < id:
                     ind+=1
                     indices.append(ind)
                  for indice in indices:
                     indiceNodoG = (ladoG[1] == 'dir' and (indiceNodoG +1) or (indiceNodoG -1))
                     self.populacao[ini].insert(indice, melhorRota[indiceNodoG])                        #ADICIONANDO ELEMENTOS A DIREITA NO VETOR DE MELHOR ROTA
               except Exception, e:
                  pass
            ############################################
            #INSERIR ELEMENTOS PARA QUE ROTA CONTENHA TODAS CIDADES
            ############################################
            list = []
            list= self.populacao[ini]
            c = 0
            try:
               while not self.__sublist(self.populacao[ini], self.cidades) and c<50:                                                            #TENTO 20 VEZES INSERIR ELEMENTO NA LISTA PARA COMPLETA-LA
                  cont=0
                  c+=1
                  elem = self.cidades[random.randint(0, len(self.cidades)-1)]
                  while elem in list and cont < 50:
                     elem = self.cidades[random.randint(0, len(self.cidades)-1)]
                     cont+=1
                  if cont < 50:
                     if self.adjacencia(elem, self.populacao[ini][len(self.populacao[ini])-1]):                                                      #VERIFICA ADJACENCIA ENTRE O ELEMENTO E O ULTIMO DO VETOR
                        self.populacao[ini].append(elem)
                        break
            except Exception, e:
               print 'Erro ao completar rota, ', e
            res = self.geraFitnes(self.populacao[ini], 0)                                                                                          #VERIFICO AQUI SE TAMANHO TOTAL DE ELEMENTOS JA FOI CRIADO ANTES SE INSERIR CADA ELEMENTO
            self.populacao[ini].insert(0, res[0])
            self.populacao[ini].insert(1, res[1])
            ini+=1
      except Exception, e:
         pass
   def __header(self):
      try:
         print "**************************************************************************************"
         print "*   ALGORITMO GENETICO  - HEURISTICA DO CAIXEIRO VIAJANTE              UNI-BH        *"
         print "*   AUTOR: CESAR T. SILVA, SABRINE HEQUER - cesarts25@gmail.com / sabrinesa@gmail.com*"
         print "*   DISCIPLINA: INTELIGENCIA ARTIFICIAL       PROF: ANA PAULA LADEIRA  CCM7          *"
         print "**************************************************************************************"
         print ""
         print "                   PARAMETROS DE ENTRADA PARA O AG             "
         print "PROBABILIDADE DE MUTACAO  = %f"%self.mutacao
         print "PROBABILIDADE DE CRUZAMENTO = %f"%self.crossover
         print "PROBABILIDADE DE NAO ALCANCABILIDADE ENTRE CIDADES = 1/%d"%self.NAOALCANCO
         print "TAMANHO DA POPULACAO = %d"%self.tamPopulacao
         print "CIDADES - ",  self.cidades
         print "DISTANCIA MAXIMA ENTRE AS CIDADES = %d"%self.MAX_DIST
         print "NUMERO DE GERACOES = %d"%self.geracoes
         print "NUMERO DE THREADS UTILIZADAS = %d"%self.NUM_THREADS
         print ""
         print "                   MATRIZ DE ADJACENCIA             "
         c = " "
         for i in self.cidades:
            c += "    "+i
         print c
         for i in self.cidades:
            c = []
            for j in self.cidades:
               c.append(self.distancia[i][j])
            print i, c
         print ""
         print ""
         print "                   RESULTADOS OBTIDOS             "
         print "MELHOR ROTA - ", self.populacao[0][2:]
         print "CUSTO EM KM - ", self.populacao[0][1]
         print "TEMPO GASTO PELO ALGORITMO - ", self.time, " segundos."
         print ""
         pop = raw_input("IMPRIMIR POPULACAO (S/N):  ")
         if pop.lower() =='s':
            print "                   POPULACAO  INICIAL           "
            for i , j in enumerate(self.populacaoInicial):
               print i , '-  ', j
         if pop.lower() =='s':
            print "                   POPULACAO  FINAL           "
            for i , j in enumerate(self.populacao):
               print i , '-  ', j
         print ""
         print "                BELO HORIZONTE %s"%(strftime("%d/%m/%Y"))
      except Exception, e:
         print e

###################
#INSTANCIA CLASSE
####################
if __name__ == "__main__":
   try:
      print "           --  COLETA DE DADOS -- "
      ger = input("NUMERO DE GERACOES: ")
      pop = input("TAMANHO DA POPULACAO: ")
      citys = input("NUMERO DE CIDADES: ")
      c = []
      c.extend(str(city) for city in range(citys))
      print "                    CALCULANDO ROTA..."
      ag =  AG(0.3,0.7,pop,'2x+30x2', c, 1200, ger,  4, 50)
   except Exception, e:
      print e

--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

DNS público do Google

Para usar o dns público do Google, basta configurar seu DNS para


8.8.8.8 e 8.8.4.4

Mais informações em

http://code.google.com/intl/pt-BR/speed/public-dns/

--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

CouchDB - Um Banco de dados Adhoc?

Olhando rapidamente a documentação do CouchDB, a impressão que tive é que ele é extremamente útil em situações em que um banco de dados relacional não é adequado, isso é, ele permite que haja campos diferentes para cada documento.

Ainda tenho que avaliá-lo com mais calma, mas me parece útil para situações que hoje usam XML, mas que nunca usei por considerar XML muito chato.



--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

Work: Software open source para mapeamento de processos

Estou desenvolvendo uma ferramenta opensource para mapeamento de processos: o Work.

Ela permite mapear, simular e documentar os processos.

A abordagem é bastante simplificada para permitir utilização por um público mais amplo.

Uma demonstração está disponível em http://www.hipercenter.com/work



--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

Short tutorial to migrate web2py database - model and data

Short tutorial

1. To export your sqlite database, use the shell:

db.export_to_csv_file(open('somefile.csv', 'wb'))

2.  create a empty postgresql database, and change
    db = DAL('sqlite://storage.sqlite')     

to   

    # db = DAL('sqlite://storage.sqlite')       # if not, use SQLite or other DB
    db = DAL("postgres://user:password@localhost:5432/yournewdatabase")



3. and to import:

db.import_from_csv_file(open('somefile.csv', 'rb'))

--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

Web2py: Recaptcha in SQLFORM

Although you may be able to do this, captcha is not a widget because
as pointed out it is not a field.
This is the best way.

form[0].append(TR('',captcha, ''))

Dica do Massimo

--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

web2py - rounded corners - chrome, safari e firefox

in your view write
-----------------------------------------------
<div class="box">
test
</div>

in static/base.css add
-----------------------------------------------
.box {
-moz-border-radius: 5px;/*for firefox3*/
-webkit-border-radius: 5px;/*for safari and chrome*/
background-color: rgb(249,249,249);
background-image: url("../default/border_radius?
r=4&color=249,249,249&bg=235,232,230");/*for opera*/
}

in controllers/default.py add
-----------------------------------------------
def border_radius():
import re
try:
radius = request.vars['r']
except KeyError:
radius = 5
try:
color = request.vars['color']
if re.match('\d{3},\d{3},\d{3}',color):
color = 'rgb(%s)'%color
except KeyError:
color = 'rgb(249,249,249)'
try:
bg = request.vars['bg']
if re.match('\d{3},\d{3},\d{3}',bg):
bg = 'rgb(%s)'%bg
except KeyError:
bg = 'rgb(235,232,230)'
import gluon.contenttype
response.headers['Content-Type']= gluon.contenttype.contenttype
('.svg')+';charset=utf-8'
return '''<?xml version="1.0" ?> <svg xmlns="http://www.w3.org/
2000/svg"> <rect fill="%s" x="0" y="0" width="100%%" height="100%%" />
<rect fill="%s" x="0" y="0" width="100%%" height="100%%" rx="%spx" />
</svg>'''%(bg,color,radius)
-----------------------------------------------
you'r done

for WebKit (Safari, Chrome) and Gecko (Firefox) the experimental css3
property is used to create the rounded corners and for Opera an SVG
image with rounded corners is generated and used as background

happily stolen from http://home.e-tjenesten.org/~ato/2009/08/border-radius-opera

Why? Because I did not want to create complicated tables/complicated
css and java scrip rounded corners always made my site very slow and i
dont give a .. for IE.

Hint: you can also do something like
background-image: url("../default/border_radius?
r=50&color=red&bg=blue");
--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

Linux Hardening

Para quem se interessa por segurança, uma das coisas mais importantes que devemos realizar em servidores é o que se chama de Hardening, isso é, uma configuração que permita que os serviços desnecessários sejam desativados e os recursos sensíveis, protegidos.

O simples fato de uma máquina estar conectada à internet já representa um risco em potencial. Uma boa experiência para comprovar isso é configurar um IDS (Snort, por exemplo) e depois de um dia apenas analisar seus logs. Veremos várias tentativas de invasão, por qualquer método que nos assustaremos. Não apenas no que diz respeito a servidores, mas também à desktops.

Para quem quer conhecer um pouco mais sobre o assunto, seguem abaixo dois links, um para um texto outro para uma apresentação sobre Linux Hardening:

Artigo - http://www.csirt.pop-mg.rnp.br/docs/hardening/linux.html

Apresentação - http://www.rfdslabs.com.br/wp-content/uploads/2007/06/hardening-linux-2.ppt

--

Dica de http://www.vivaolinux.com.br/dica/Linux-Hardening
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

SSH: Como resolver problema de demora para digitar usuário e senha

Descrição do problema:

Se para conectar via SSH a um servidor você enfrenta uma certa demora para ser solicitado o usuário e senha, ou seja, você conecta e aguarda alguns segundos para receber a solicitação "Login as: ", então digita o usuário e aperta "enter", e aí demora entre 30 segundos e 2 minutos para receber a solicitação de "password:"...

Imagine esta situação quando um serviço crítico precisa de manutenção e você não consegue nem conectar no servidor... cada segundo é uma eternidade!

Como resolver:

Este problema está relacionado à autenticação utilizando GSSAPI, que é relacionada a autenticação Kerberos. Se você nunca ouviu falar disso ou não utiliza este sistema de autenticação, deve desabilitar, o que vai acabar com a demora para conectar:

Para isto, edite o arquivo /etc/ssh/sshd_config e retire o comentário (#) ou modifique a linha abaixo para ficar da seguinte forma:

GSSAPIAuthentication no

Explicação:

Existe um bug em algumas versões de servidor SSH (sshd) onde o default desta opção é "on"... que faz com que o servidor SSH fique tentando autenticar via Kerberos. Desabilitando, você resolve o problema.

Espero que seja útil!

--
Dica de http://www.vivaolinux.com.br/dica/SSH-Como-resolver-problema-de-demora-para-digitar-usuario-e-senha

Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

Serviço virtual do governo de SP calcula chances de encontrar trabalho

Redação do IDG Now!

17-11-2009

Termômetro Nacional do Emprego compara, na web, o perfil de candidato com informações de vagas em seis regiões metropolitanas do país.

O governo do estado de São Paulo anunciou nesta terça-feira (17/11) o Termômetro Nacional do Emprego – ferramenta online que calcula a chance de colocação no mercado de trabalho para quem está desempregado.

Utilizando dados da Pesquisa Mensal de Emprego (PME) do IBGE acumulados desde 2002, o programa analisa as chances de êxito na busca de trabalho para os próximos 30, 60 e 90 dias.

Este cálculo representa as chances médias do grupo representado pela pessoa que faz a consulta.

Além de São Paulo, Porto Alegre, Salvador, Recife, Rio de Janeiro e Belo Horizonte são as regiões metropolitanas que também participam da PME

--

Sem dúvida, interessante

Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com

Polaris – Google Analytics Desktop

Para quem tem um blog ou mesmo site em produção seguramente quer saber como anda a visitação. Para isso existe o google analytics , que te fornece uma série de estatísticas sobre o assunto. Este serviço que o google nos oferece é muito importante porém as vezes é confuso na apresentação daquilo que é essencial. Pensando nisso acabei descobrindo uma aplicação em Air ( ADOBE ) chamada Polaris para o Google Analytics que funciona no Desktop. Neste caso  você não precisa acessar o site do google para ver suas estatísticas e pode visualizar tudo isso em seu Desktop de maneira intuitiva e simples. Existem versões para Windows, Linux e Mac. O programa é gratuíto e tem uma interface bem acabada.Nos testes que efetuei  se comportou bem e cumpriu aquilo que se propõe.
Para saber mais a respeito acesse o site da aplicação  !

http://pauloamaral.blog.br/polaris-google-analytics-desktop/

--
Atenciosamente

--
=========================
Alexandre Andrade
Hipercenter.com