Binding sites y Regulatory Motifs son dos términos que significan lo mismo, solo que desde diferentes puntos de vista. Desde el punto de vista de la proteína, lo que necesita para adherirse al gen es un binding site. Pero si nos interesa estudiar el comportamiento del gen, referirnos al regulatory motif del mismo, que sirve como trigger del proceso de transcripción.

Es por ello que el paper, a structure based aproach for prediction of protein binding sites in gene upstream regions, brinda otra forma de resolver el mismo problema. El punto detrás es que la mayoría de algoritmos se centran en los genes almacenados en bases de datos, y por ende, en hallar en las secuencia el patrón del motif, ellos se centran más bien en la relación de la proteína con el binding site del gen. para ello es importante recordar que existe  una función de correspondencia  entre los aminoacidos de la proteina y las bases nitrogenadas del ADN,  esto conlleva a poder predecir posibles binding sites en función de la proteína que se añada.

Los análisis resultan más en el campo biológico que informático, por lo que no resultan de mayor interés para la tesis. Sin embargo, si constituye una opción válida desde el punto de vista biológico.

Del paper Finding Motifs in the twilight zone, obtuve información muy precisa referente a la definición del problema, las soluciones existentes y cómo se replantea la solucion por medio de la mejora de un algoritmo tipo ESD ( extended sample driven).

Primero que nada, el problema en su forma más abstracta consiste en hallar una subcadena que se repite con frecuencia en ciertas secuencias del DNA, llamados genes, en los cuales se adhiere una proteina provocando la producción de otra en función de las necesidades del organismo. El problema detrás es que

1. no se conoce a priori cómo esta constituida esta cadena, llamada regulatory motif.

2. existen mutaciones dentro de la misma, lo cual hace su identificación más dificil.

Las soluciones existentes se remontan dede 1995, y existen desde soluciones greedy, gibbs sampling y EM. Todas estas soluciones no pasaron una prueba llamada the  Motif Challenge Problem, en la cual se intenta hallar un motif (15,4) es decir de longitud l = 15  con 4 mutaciones en un conjunto de 20 secuencias con l=600.  cabe recalcar que cuando se habla de n-bp sequences se refiere a secuencias de n letras. Una diferencia importante con respecto a los demas resulto el algoritmo WINNOWER cuyo background es el uso de EM, expectation maximization.

Todas estas soluciones mencionadas anteriormente tuvieron tiempos de ejecución y consumo de recursos muy elevados, excepto los algoritmos pattern driven. El pattern driven consiste en probar todos los elementos del conjunto de 4 a la l posibles soluciones , es decir si tengo que l es 15 tendria un conjunto de solucion con 4 a la 15 elementos. Aunque se ve enorme, el siguiente paso es valorar cada patron con una funcion F que le de valores mas altos a los patrones mas recurrentes. Notese que para valores de l elevados, se vuelve muy tedioso.

Es alli donde entra la estrategia sample driven, que consiste en escoger patrones semilla, o seed patterns a traves de los cuales se siguen buscando patrones afines. Esto tiene su riesgo ya que si se escoge mal el seed, los siguientes pasos resultan inútiles.

Pero, para secuencias de 1600 bp para arriba  estas estrategias no son eficientes en su ejecución. Es por eso que se plantea la opción de usar un hibrido entre pattern driven y sample driven, denominado extended sample driven (ESD). Sea la secuencia buscada (l ,k) donde se generan k vecinos para cada subcadena de longitud l.  Esto nos llevaria a un numero aproximado de n N(l k) *3 elevado a k, mucho menor que 4 a la l, por lo que resulta con un tiempo relativamente menor.

Sin embargo, todavia, para cadenas de 1300 de longitud resulta prohibitivo para todas las soluciones anteriores, es por ello que resulta importante seguir explorando otras posibles estrategias orientadas a soluciones mas eficientes.

Hoje vou responder um email de uma leitora a Heloisa, que me pediu para falar mais sobre o algoritmo bubble sort, vamos lá.

Algoritmo 1:

1. Procedimento BubbleSort(Vetor)
2. var AUX {variavel de apoio}
3. Inicio
4. para i=0 até n-1 faça
5. para j=0 até n-1 faça
6. se vetor[j] > vetor[j+1] então
7. AUX = vetor[j]
8. vetor[j] = vetor[j+1]
9. vetor[j+1] = AUX
10. fim_se
11. fim_para
12. fim_para

O Bubble Sort ou “metodo bolha” como é chamado, consiste em correr um vetor comparando cada elemento com o elemento seguinte:

vetor[j] > vetor[j+1]

No caso de organizar as informações crescente, se o elemento comparadao com o vetor[i] for menor (<) ou igual (=) ao elemento, nada se faz, porém se o elemento comparado com o vetor[i] for maior (>) que o elemento, inverte-se a posição dos 2 elementos, comparando assim com todos os elementos até finalizar o vetor.

O máximo de execuções que esse algoritmo faz para que o vetor fique ordenado é (N-1), em que N é o número de elementos do vetor.

Existe também uma variação do algoritmo Bubble Sort, onde não existe uma variável Auxiliar, para fazer a troca utiliza-se um calculo matemático, no começo parece estranho como ele trabalha mas analisando bem é fácil de assimilar.

vejamos:

Digamos que:

• j = 5
• i = 3

Então

• j = j + i –> 5 + 3 = 8
• o j agora vale 8
• i = j – i –> 8 – 3 = 5
• agora o i vale 5
• j = j – i –> 8 – 5 = 3
• agora o j vale 3

Pronto trocamos os vales fazendo calculos, depois disso o valor inverte;

• j = 3
• i = 5

Vejamos o algoritmo:

Algoritmo 2:

1. Procedimento BubbleSort(Vetor)
2. Inicio
3. para i=0 até n-1 faça
4. para j=0 até n-1 faça
5. se vetor[i] > vetor[j] então
6. vetor[j] = vetor[j] + vetor[i]
7. vetor[i] = vetor[j] – vetor[i]
8. vetor[j] = vetor[j] – vetor[i]
9. fim_se
10. fim_para
11. fim_para

Utilizando as linguagem de programação PASCAL e C, veremos abaixo como fica o algoritmo nas duas linguagens:

Em Pascal:

Em C

• void BubbleSort(Vetor A){
• int aux, i, j;
• for(i=0;i<n;i++){
• for(j=0;j<n;j++){
• if(a[j] > a[j+1]){
• aux = a[j];
• a[j] = a[j+1];
• a[j+1] = aux;
• }
• }
• }
• }

ALGORITMOS

DESCRIPCIÓN:

La algoritmia es el estudio de problemas matemáticos y lógicos que pueden ser implementados en un lenguaje de computación siguiendo las reglas secuénciales que la metodología describa. Adicionalmente se debe tener en cuenta el uso de dispositivos de entrada/salida requeridos para incluirlos en el algoritmo.

Los algoritmos en computación tienen una simbología propia y universal que permiten transcribir la solución de un problema ya sea esquemáticamente o textualmente.

OBJETIVO GENERAL:

Interpretar problemas matemáticos, de comparación lógica y manejo de datos, para  convertirlos en algoritmos computacionales.

JUSTIFICACIÓN:

La programación de computadores requiere que las personas dedicadas a esta labor tengan los fundamentos básicos de la lógica de programación y saber como abstraer un  problema a resolver e interpretarlo en un algoritmo, para posteriormente codificarlo en un lenguaje de programación.

METODOLOGIA:

• Presentación de temas por parte del profesor
• Presentación y desarrollo de temas con participación de estudiantes
• Formulación, explicación y solución a ejemplos y problemas de aplicación
• Realización de talleres en grupo o individual por parte de los estudiantes y con asistencia del profesor
• Prácticas de laboratorio asistidas por el profesor o foros de discusion
• Prácticas realizadas por los estudiantes en horarios extra-clase
• Realización de evaluaciones programadas

EVALUACIÓN:

Se acordará con los estudiantes teniendo como marco de referencia la siguiente propuesta:

• Trabajos en grupos:   desarrollo y presentación
• Evaluaciones

ESTRUCTURA DEL CURSO

El número Pi (π) es uno de los números más importantes en la matemática y, por ende, en las ciencias. Pero no seré yo quien les explique la importancia de este número (que todos de por sí deberían saber). La wikipedia en español nos dice:

π (pi) es la relación entre la longitud de una circunferencia y su diámetro, en Geometría euclidiana. Es un número irracional y una de las constantes matemáticas más importantes. Se emplea frecuentemente en matemáticas, física e ingeniería. El valor numérico de π, truncado a sus primeras cifras, es el siguiente:

El valor de π se ha obtenido con diversas aproximaciones a lo largo de la historia, siendo una de las constantes matemáticas que más aparece en las ecuaciones de la física, junto con el número e. Por ello, tal vez sea la constante que más pasiones desata entre los matemáticos profesionales y aficionados. La relación entre la circunferencia y su diámetro no es constante en geometrías no euclídeas.

En este post vamos a ver dos maneras, la segunda basada en la primera, de obtener el número π con más o menos buena precisión, aprovechando la potencia computacional de la que disponemos hoy en día. Pero, como supondrán, habrán matemáticas en el proceso. Los algoritmos completos en python están al final del post, para los que quieran saltarse el proceso.

Si nos acordamos de nuestros cursos de cálculo diferencial (en caso de que los hayamos tenido, claro) se nos aparecerá que la derivada del arcotangente de x es:

Por otro lado, tenemos la siguiente serie geométrica infinita, válida para |x| < 1:

Ahora, para hallar una fórmula que nos exprese el arcotangente de x, simplemente integramos la expresión:

quedándonos una serie geométrica infinita así:

Sabemos, y eso es algo básico que aparte cualquier calculadora nos puede decir, que:

de modo que, reemplazando con la serie que teníamos más arriba:

Acá tenemos un problema, puesto que nuestra serie es válida, como decía antes, para todo |x| < 1. Sin embargo, se puede demostrar que lo escrito arriba es cierto. Así que obviaremos esto.

Luego, ya podemos calcular el número pi:

Sin embargo este método es lento. Lento es lento. Se necesitan demasiadas sumas para llegar a una precisión aceptable. Por ejemplo, con 100 000 000 sumas, el número que da es 3.14159264359. Eso no es aceptable.

Surge entonces la necesidad de idear otro algoritmo más eficiente. Si nos acordamos de trigonometría del colegio, veremos por ahí una fórmula para la tangente de a + b:

Si tomamos a = arctan(1/2) y b = arctan(1/3), y aplicamos luego la función arctan a ambos lados de la ecuación, nos queda lo siguiente:

Luego, no es más que aplicar la serie geométrica para arctan(x) en casa caso y sumar:

Se puede notar que en este caso se llega a la precisión mucho más rápido. A continuación, los algoritmos en python:

Primer algoritmo (complejidad O(n^10)):

from decimal import *
decimals = 4
getcontext().prec = decimals+3
sums = pow(10, decimals+1)
i = Decimal(1)
pi = Decimal(1)
while i < sums:
    pi = pi + (pow(-1,i) / ((Decimal(2)*i)+Decimal(1)))
    i = i + Decimal(1)
getcontext().prec = decimals+1
print (pi * 4)


Segundo algoritmo (complejidad O(n)):

from decimal import *
decimals = 20
sums = (decimals+1) * 2
getcontext().prec = decimals+1
i = Decimal(1)
pi1 = Decimal(1)/Decimal(2)
pi2 = Decimal(1)/Decimal(3)
while i < sums :
    pi1 = pi1 + pow(-1,i)*((pow(Decimal(1)/Decimal(2),((Decimal(2)*i)+Decimal(1)))/((Decimal(2)*i)+Decimal(1))))
    pi2 = pi2 + pow(-1,i)*((pow(Decimal(1)/Decimal(3),((Decimal(2)*i)+Decimal(1)))/((Decimal(2)*i)+Decimal(1))))
    i = i + 1
print ((pi1+pi2) * 4)

Para aquellos que como yo estén sufriendo de la asignatura MTP2, os muestro una serie de enlaces de youtube, que os los explican pasiiiito a pasiiiito, bubblesort, insertsort, mergesort y quicksort

http://www.youtube.com/view_play_list?p=89B61F78B552C1AB

Lo vi en un tuit de JJ Merelo y enlaza a un artículo curioso: A Genetic Programming Approach to Automated Software Repair (pdf). Proponen utilizar algoritmos genéticos para resolver fallos en los programas: esencialmente se trata de ajustar los parámetros del algoritmo para que proporcione valores malos con programas modificados que no pasan los tests y que proporcionan valores buenos cuando se cumplen las restricciones del problema.
Curioso.

Ya habíamos hablado en vidas anteriores de Algoritmos evolutivos y el gcc (se usaban para optimizar la selección de parámetros que se le pasan al compilador). También de Algoritmos genéticos, spam y expresiones regulares y de Algoritmos genéticos: historias de éxito interesantes.

Marco teórico:

El algoritmo de Prim es un algoritmo de la teoría de los grafos para encontrar un árbol recubridor mínimo
en un grafo conexo, no dirigido y cuyas aristas están etiquetadas.
En otras palabras, el algoritmo encuentra un subconjunto de aristas que forman un árbol con todos los
vértices, donde el peso total de todas las aristas en el árbol es el mínimo posible. Si el grafo no es conexo,
entonces el algoritmo encontrará el árbol recubridor mínimo para uno de los componentes conexos que
forman dicho grafo no conexo [?] .

Implementación en Python:

#!/usr/bin/python
#        Copyright (C) 2009 fitorec - chanerec@gmail.com
#        Archivo	: prim.py
#        Creado     : 2009-05-31
#        Modificado : 2009-05-31
#       ======================= Descripcion ===========================
#		Input: leemos el grafo de un archivo denominado "grafo" el cual
#				debera estar en el mismo directorio.

import sys, re, string
print "archivo de entrada: 'grafo'"

#funcion auxiliar para extraer los datos del archivo
def extrDatos(linea):
	l = []
	v0 = re.compile("[[a-zA-Z]+ ")
	v1 = re.compile(" [[a-zA-Z]+ ")
	v2 = re.compile("[0-9]+")
	line = re.compile("[a-zA-Z]+ [a-zA-Z]+ [0-9]+")
	mo = line.search(linea)
	if mo:
		print mo.group(0)
	mo = v2.search(linea)
	l2 = []
	if mo:
		l.append(int(mo.group(0)))
	mo = v0.search(linea)
	if mo:
		l.append(mo.group(0).replace(" ",""))
	mo = v1.search(linea)
	if mo:
		l.append(mo.group(0).replace(" ",""))
	l.append(False)
	return l

#revisa si la arista y si alguno de sus nodos no han sido  marcados
def entra(nodo,arista):
	if arista[3] == True :
		return False
	if nodo[0] == arista[1]:
		return True
	if nodo[0] == arista[2]:
		return True
	return False

#revisa si el el vertice v conduce a un nodo nuevo en visitados
def noVisitado(v,visitados):
	if v[3] == True:
		return "$"
	for i in visitados:
		if i[1] == True:
			continue
		if i[0] == v[1]:
			return i[0]
		if i[0] == v[2]:
			return i[0]
	return "$"

f = open("grafo","r")
grafo = []
visitados = []

while True:
     entrada = []
     linea = f.readline()
     if not linea: break
     if re.match("[a-zA-Z]+ [a-zA-Z]+ [0-9]+",linea) :
     	grafo.append(extrDatos(linea))

grafo.sort()

#insertando los nodos a visitados
for i in grafo:
	band = True
	for j in visitados:
		if i[1] == j[0]:
			band = False
			break
	if band == True:
		visitados.append([i[1],False])
	band = True
	for j in visitados:
		if i[2] == j[0]:
			band = False
	if band == True:
		visitados.append([i[2],False])

#iniciando el algoritmo de prim
visitados[0][1] = True;
band = False;
print "\nSe inicio el algoritmo PRIM con el nodo %s" % visitados[0][0]
while band == False:
	vertices = []
	band = True
	for i in range(len(visitados)):
		if visitados[i][1] == False:
			continue
		for j in range(len(grafo)):
			if entra(visitados[i],grafo[j]):
				vertices.append(j)

		vertices.sort()
	for i in vertices:
		s = noVisitado(grafo[i],visitados)
		if s == "$":
			continue
		print "Conociendo %s a traves [(%s,%s),%s]" % (s,grafo[i][1],grafo[i][2],grafo[i][0])
		for j in visitados:
			if j[0] == s:
				j[1] = True
		grafo[i][3] = True
		break
	for n in visitados:
		if n[1] == False:
			band = False
			break

print "\nArbol de expansion minima: "
for i in grafo:
	if i [3] == True:
		print "[(%s,%s),%s]" % (i[1],i[2],i[0])

Corrida de ejemplo:

Para la corrida de ejemplo necesitamos un archivo de entrada el cual describa un grafo para esto he elegida el grafo de la documentacion de wikipedia http://es.wikipedia.org/wiki/Algoritmo_de_Prim .

Grafo a utlizar (Extraido de Wikipedia)

Ahora necesitamos insertale al algorimo el grafo par este caso hemos generado el siguiente archivo denominado grafo el cual tine el siguinente formato (nodoA nodoB pesoEntreAyB), veamos el grafo que describe la imagen antes mostrada.

A B 7
A D 5
B C 8
B E 7
D E 15
D F 6
F E 8
F G 11
E G 9
C E 5
B D 9

Pasos:

Paso 1:Ninguna de las aristas está marcada, y el vértice A ha sido elegido arbitrariamente como el punto de
partida.
Paso 2: El Primer vértice es el más cercano a A es D está a 5 de distancia,ya que B se localiza a una
distancia de 7, así que marcamos la arista [(A,D),5] y el nodo A como visitado.
Paso 3: Ahora que solo conoce al Nodo A y D el nodo siguiente por conocer es F a travez de la arista
3
[(D,F),6].
Paso 4: Conociendo B a traves [(A,B),7]
Paso 5: Conociendo E a traves [(B,E),7]
Paso 6: Conociendo C a traves [(C,E),5]
Paso 7: Conociendo G a traves [(E,G),9]

salida en linea de comando

Por ultimo muestro la salida en linea de comandos al ejecutar el script.

usuario@host$./prim.py
archivo de entrada: ’grafo’
A B 7
A D 5
B C 8
B E 7
D E 15
D F 6
F E 8
F G 11
E G 9
C E 5
B D 9
Se inicio el algoritmo PRIM con el nodo A
Conociendo D a traves [(A,D),5]
Conociendo F a traves [(D,F),6]
Conociendo B a traves [(A,B),7]
Conociendo E a traves [(B,E),7]
Conociendo C a traves [(C,E),5]
Conociendo G a traves [(E,G),9]
Arbol de expansion minima:
[(A,D),5]
[(C,E),5]
[(D,F),6]
[(A,B),7]
[(B,E),7]
[(E,G),9]

Decargar Codigo

Olá a todos, há alguns dias atrás um amigo me pediu um algoritmo de uma pessoa acordando, então comecei a descrever os passos necessários (segundo o meu ponto de vista) para completar esta tarefa, após algumas instruções ele me interrompeu e disse que havia erros no meu “código”, curioso quis observar o “debug” dele.
Ele me disse que eu deveria ter adicionado uma instrução para respirar.
Logo retruquei: –E por acaso você necessita se concentrar e relembrar a si mesmo de que precisa respirar!? Pelo que sei o ato de respirar independe da vontade da pessoa, senão ao dormir morreríamos. Como argumento ele respondeu que não se trata de uma pessoa e sim de um algoritmo, por isso é preciso adicionar a instrução. Logo respondi que este nível de complexidade depende do projeto apresentado; ele me pediu um algoritmo descrevendo os passos necessários para UMA PESSOA acordar e NÃO UM ROBÔ!!! E mesmo se fosse um robô, por que iria precisar dessa instrução? Por acaso é um ANDROID!? E nisso volto a questão inicial: Qual a real dimensão do problema a ser resolvido? Em qual tipo de linguagem será escrito, de alto nível ou baixo nível?
O maior erro cometido por alguns desenvolvedores é não terem idéia do problema que terão de resolver, e não é do macroprocesso apenas que estou falando e sim do conceito “dividir para conquistar”.Por vezes observo casos onde os problemas não são divididos de forma equilibrada.
Continua…

Boa noite a todos que por aqui passam! Hoje veremos algumas dicas que podem ser interessantes a você que programa em Delphi.

Convertendo um JPG para BMP

Se você precisa gravar uma imagem numa tabela no banco de dados e acha confuso trabalhar com TBlobStream, eis uma dica que pode ser util, converter uma imagem JPG em bitmap.

procedure JPEGtoBMP(const FileName: TFileName);
var
 jpeg: TJPEGImage;
 bmp:  TBitmap;
begin
 jpeg := TJPEGImage.Create;//criamos uma imagem jpg
 try
 jpeg.CompressionQuality := 100; //aqui definimos a qualidade da compressão(quanto maior,

menor será o arquivo). 100 é o valor default.
 jpeg.LoadFromFile(FileName); //carregamos a imagem
 bmp := TBitmap.Create; //criamos nosso bitmap
 try
 bmp.Assign(jpeg);//passamos o conteudo da váriavel jpeg para a variavel bmp
 bmp.SaveTofile(ChangeFileExt(FileName, '.bmp'));//por fim salvamos o arquivo.
 finally
 bmp.Free //liberamos o bmp da memória
 end;
 finally
 jpeg.Free //liberamos o jpeg da memória.
 end;
end;

Imitando a função RPAD/LPAD do MySQL.

A função RPAD e LPAD do MySQL é uma função que pode nos ser muito util, por exemplo, no caso de querermos exibir e/ou gravar no banco de dados ou onde quer que seja um valor preenchido com zeros a esquerda ou a direita por exemplo.
A função abaixo mostrará como preencher uma string com n caracteres informados pelo programador.

function LPAD(const texto: string; const Caracter: char;num_vezes: integer): string;
var
 contador: integer; //variavel auxiliar para o laço
 auxiliar: string;  //variavel auxiliar para montar nossa string
begin
 auxiliar := texto;//auxiliar recebe o texto informado
 contador := 1;//inicia nosso contador
 while contador <= num_vezes do//executa enquanto o contador for menor ou igual a num_vezes
 begin
 Insert(Caracter, auxiliar, 1);//função do delphi que insere uma string em outra no index
//informado(index 1 é o inicio da string)
 inc(contador);//incrementa o contador, se não o fizer, teremos um laço infinito 
 end;
 result := auxiliar;//retorna a nossa string montada
end;

A função acima irá inserir Caracter n(num_vezes) vezes a esquerda da string passada como

parametro.

Para a função RPAD, é praticamente o mesmo código, só mudaremos a linha do insert, que receberá o último index da string.

Insert(Caracter, auxiliar, length(auxiliar) + length(texto));//irá último index da string

Na faculdade, na aula de programação a professora nos pediu para gerarmos um sudoku válido. Depois de tantas tentativas sem sucesso, encontrei este algoritmo polinomial em Java(que pode ser facilmente traduzido para C++) na Wikipedia:

final int n = 3;//aqui vai o numero de elementos do seu sudoku(3 vai ser um sudoku 3x3
final int[][] field = new int[n*n][n*n];//matriz onde será armazenado o sudoku
int x = rand()%10;//semente aleatória para não gerar o mesmo sudoku
for(int i = 0; i < n; i++, x++)
	for(int j = 0; j < n; j++, x+=n)
		for(int k = 0; k < n*n; k++, x++)
			field[n*i+j][k] = (x % (n*n)) + 1;