Skip to content

Commit a17d8ce

Browse files
Rahbrandreasprlic
Rahbr
authored and
andreasprlic
committed
/* Como eu posso contar os Residuos em uma Sequence? */
1 parent 2acc057 commit a17d8ce

2 files changed

Lines changed: 283 additions & 0 deletions

File tree

‎wiki/BioJava:CookbookPortuguese:Count:Residues.md‎

Lines changed: 145 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,145 @@
1+
---
2+
title: BioJava:CookbookPortuguese:Count:Residues
3+
---
4+
5+
Como eu posso contar os Residuos em uma Sequence?
6+
-------------------------------------------------
7+
8+
Contar os resíduos em uma Sequence é uma tarefa muito comum na
9+
bioinformatica. Geralmente você construiria um array de inteiros e
10+
usaria algum sistema indexador. Melhor ainda, você poderia usar um
11+
AlphabetIndex para impor um índice unificado. Você obteria um do
12+
AlphabetManager que usa um de seus métodos getAlphabetIndex(). Porque
13+
este tipo de atividade é tão comum que o BioJava empacotou tudo
14+
indexação etc em uma classe chamada IndexedCount que é uma implementação
15+
da interface Count.
16+
17+
O programa seguinte lê algum tipo de arquivo de sequencia e conta os
18+
resíduos, imprimindo seu resultados para STDOUT. Note que este programa
19+
não trabalha com símbolos de ambigüidade. Se você desejar contar
20+
símbolos de ambigüidade, você precisa adicionar uma conta parcial para
21+
cada Symbol que compõe a ambigüidade se esta for seu caso, você usaria
22+
esta solução.
23+
24+
### Solução 1
25+
26+
<java> import java.io.\*; import java.util.\*;
27+
28+
import org.biojava.bio.dist.\*; import org.biojava.bio.seq.\*; import
29+
org.biojava.bio.seq.io.\*; import org.biojava.bio.symbol.\*;
30+
31+
public class CountResidues {
32+
33+
` /**`
34+
`  * Pega 3 argumentos, primeiro é o arquivo da sequencia o segundo é o`
35+
`  * formato da sequencia (case insensitive) e o terceiro é a sequencia`
36+
`  * do alphabet (ex DNA, também case insensitive)`
37+
`  */`
38+
` public static void main(String[] args) {`
39+
`   //referencia para object to manter os contadores`
40+
`   Count counts = null;`
41+
42+
`   try {`
43+
`     //abre o arquivo de sequencia`
44+
`     BufferedReader br = new BufferedReader(new FileReader(args[0]));`
45+
46+
`     //adquire um SequenceIterator para as sequencias no arquivo`
47+
`     SequenceIterator iter =`
48+
`         (SequenceIterator)SeqIOTools.fileToBiojava(args[1],args[2],br);`
49+
50+
`     //para cada sequence`
51+
`     while(iter.hasNext()){`
52+
`       Sequence seq = iter.nextSequence();`
53+
54+
`       //se necessário, inicializa o contador`
55+
`       if(counts == null){`
56+
`         counts = new IndexedCount((FiniteAlphabet)seq.getAlphabet());`
57+
`       }`
58+
59+
`       //iterate através dos Symbols na seq`
60+
`       for (Iterator i = seq.iterator(); i.hasNext(); ) {`
61+
`         AtomicSymbol sym = (AtomicSymbol)i.next();`
62+
`         counts.increaseCount(sym,1.0);`
63+
`       }`
64+
`     }`
65+
66+
`     //agora imprime os resultados`
67+
`     for (Iterator i = ((FiniteAlphabet)counts.getAlphabet()).iterator();`
68+
`          i.hasNext(); ) {`
69+
`       AtomicSymbol sym = (AtomicSymbol)i.next();`
70+
`       System.out.println(sym.getName()+" : "+counts.getCount(sym));`
71+
`     }`
72+
`   }`
73+
`   catch (Exception ex) {`
74+
`     ex.printStackTrace();`
75+
`   }`
76+
` }`
77+
78+
} </java>
79+
80+
### Solução 2
81+
82+
<java> import java.io.\*; import java.util.\*;
83+
84+
import org.biojava.bio.dist.\*; import org.biojava.bio.seq.\*; import
85+
org.biojava.bio.seq.io.\*; import org.biojava.bio.symbol.\*;
86+
87+
public class CountResidues2 {
88+
89+
`  /**`
90+
`  * Pega 3 argumentos, primeiro é o arquivo da sequencia o segundo é o`
91+
`  * formato da sequencia (case insensitive) e o terceiro é a sequencia`
92+
`  * do alphabet (ex DNA, também case insensitive)`
93+
`  */`
94+
95+
` public static void main(String[] args) {`
96+
`   //referencia o objeto para guardar os contadores`
97+
`   Count counts = null;`
98+
99+
`   try {`
100+
`     //abre o arquivo de sequence`
101+
`     BufferedReader br = new BufferedReader(new FileReader(args[0]));`
102+
103+
`     //adquire um SequenceIterator para as sequencias no arquivo`
104+
`     SequenceIterator iter =`
105+
`         (SequenceIterator)SeqIOTools.fileToBiojava(args[1],args[2],br);`
106+
107+
`     //para cada sequence`
108+
`     while(iter.hasNext()){`
109+
`       Sequence seq = iter.nextSequence();`
110+
111+
`       //se necessário inicializa os contadores`
112+
`       if(counts == null){`
113+
`         counts = new IndexedCount((FiniteAlphabet)seq.getAlphabet());`
114+
`       }`
115+
116+
`       //iterate através dos Symbols na seq`
117+
`       for (Iterator i = seq.iterator(); i.hasNext(); ) {`
118+
`         Symbol sym = (Symbol)i.next();`
119+
120+
`         /*`
121+
`          * O Símbolo pode ser ambíguo assim soma uma conta parcial para cada Símbolo`
122+
`          * isso compõe o Símbolo de ambigüidade. Ex a ambigüidade de DNA que n é feito`
123+
`          * de um Alfabeto de quatro Símbolos, assim soma-se 0.25 ao count de cada um.`
124+
`          */`
125+
`         FiniteAlphabet subSymbols = (FiniteAlphabet)sym.getMatches();`
126+
`         for (Iterator i2 = subSymbols.iterator(); i2.hasNext(); ) {`
127+
`           AtomicSymbol sym2 = (AtomicSymbol)i2.next();`
128+
`           counts.increaseCount(sym2, 1.0 / (double)subSymbols.size());`
129+
`         }`
130+
`       }`
131+
`     }`
132+
133+
`     //agora imprime os resultados`
134+
`     for (Iterator i = ((FiniteAlphabet)counts.getAlphabet()).iterator();`
135+
`          i.hasNext(); ) {`
136+
`       AtomicSymbol sym = (AtomicSymbol)i.next();`
137+
`       System.out.println(sym.getName()+" : "+counts.getCount(sym));`
138+
`     }`
139+
`   }`
140+
`   catch (Exception ex) {`
141+
`     ex.printStackTrace();`
142+
`   }`
143+
` }`
144+
145+
} </java>

‎wiki/BioJava:CookbookPortuguese:Count:Residues.mediawiki‎

Lines changed: 138 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,138 @@
1+
== Como eu posso contar os Residuos em uma Sequence? ==
2+
3+
Contar os resíduos em uma Sequence é uma tarefa muito comum na bioinformatica. Geralmente você construiria um array de inteiros e usaria algum sistema indexador. Melhor ainda, você poderia usar um AlphabetIndex para impor um índice unificado. Você obteria um do AlphabetManager que usa um de seus métodos getAlphabetIndex(). Porque este tipo de atividade é tão comum que o BioJava empacotou tudo indexação etc em uma classe chamada IndexedCount que é uma implementação da interface Count.
4+
5+
O programa seguinte lê algum tipo de arquivo de sequencia e conta os resíduos, imprimindo seu resultados para STDOUT. Note que este programa não trabalha com símbolos de ambigüidade. Se você desejar contar símbolos de ambigüidade, você precisa adicionar uma conta parcial para cada Symbol que compõe a ambigüidade se esta for seu caso, você usaria esta solução.
6+
7+
=== Solução 1 ===
8+
9+
<java>
10+
import java.io.*;
11+
import java.util.*;
12+
13+
14+
import org.biojava.bio.dist.*;
15+
import org.biojava.bio.seq.*;
16+
import org.biojava.bio.seq.io.*;
17+
import org.biojava.bio.symbol.*;
18+
19+
public class CountResidues {
20+
21+
/**
22+
* Pega 3 argumentos, primeiro é o arquivo da sequencia o segundo é o
23+
* formato da sequencia (case insensitive) e o terceiro é a sequencia
24+
* do alphabet (ex DNA, também case insensitive)
25+
*/
26+
public static void main(String[] args) {
27+
//referencia para object to manter os contadores
28+
Count counts = null;
29+
30+
try {
31+
//abre o arquivo de sequencia
32+
BufferedReader br = new BufferedReader(new FileReader(args[0]));
33+
34+
//adquire um SequenceIterator para as sequencias no arquivo
35+
SequenceIterator iter =
36+
(SequenceIterator)SeqIOTools.fileToBiojava(args[1],args[2],br);
37+
38+
//para cada sequence
39+
while(iter.hasNext()){
40+
Sequence seq = iter.nextSequence();
41+
42+
//se necessário, inicializa o contador
43+
if(counts == null){
44+
counts = new IndexedCount((FiniteAlphabet)seq.getAlphabet());
45+
}
46+
47+
//iterate através dos Symbols na seq
48+
for (Iterator i = seq.iterator(); i.hasNext(); ) {
49+
AtomicSymbol sym = (AtomicSymbol)i.next();
50+
counts.increaseCount(sym,1.0);
51+
}
52+
}
53+
54+
//agora imprime os resultados
55+
for (Iterator i = ((FiniteAlphabet)counts.getAlphabet()).iterator();
56+
i.hasNext(); ) {
57+
AtomicSymbol sym = (AtomicSymbol)i.next();
58+
System.out.println(sym.getName()+" : "+counts.getCount(sym));
59+
}
60+
}
61+
catch (Exception ex) {
62+
ex.printStackTrace();
63+
}
64+
}
65+
}
66+
</java>
67+
68+
=== Solução 2 ===
69+
70+
<java>
71+
import java.io.*;
72+
import java.util.*;
73+
74+
75+
import org.biojava.bio.dist.*;
76+
import org.biojava.bio.seq.*;
77+
import org.biojava.bio.seq.io.*;
78+
import org.biojava.bio.symbol.*;
79+
80+
public class CountResidues2 {
81+
82+
/**
83+
* Pega 3 argumentos, primeiro é o arquivo da sequencia o segundo é o
84+
* formato da sequencia (case insensitive) e o terceiro é a sequencia
85+
* do alphabet (ex DNA, também case insensitive)
86+
*/
87+
88+
public static void main(String[] args) {
89+
//referencia o objeto para guardar os contadores
90+
Count counts = null;
91+
92+
try {
93+
//abre o arquivo de sequence
94+
BufferedReader br = new BufferedReader(new FileReader(args[0]));
95+
96+
//adquire um SequenceIterator para as sequencias no arquivo
97+
SequenceIterator iter =
98+
(SequenceIterator)SeqIOTools.fileToBiojava(args[1],args[2],br);
99+
100+
//para cada sequence
101+
while(iter.hasNext()){
102+
Sequence seq = iter.nextSequence();
103+
104+
//se necessário inicializa os contadores
105+
if(counts == null){
106+
counts = new IndexedCount((FiniteAlphabet)seq.getAlphabet());
107+
}
108+
109+
//iterate através dos Symbols na seq
110+
for (Iterator i = seq.iterator(); i.hasNext(); ) {
111+
Symbol sym = (Symbol)i.next();
112+
113+
/*
114+
* O Símbolo pode ser ambíguo assim soma uma conta parcial para cada Símbolo
115+
* isso compõe o Símbolo de ambigüidade. Ex a ambigüidade de DNA que n é feito
116+
* de um Alfabeto de quatro Símbolos, assim soma-se 0.25 ao count de cada um.
117+
*/
118+
FiniteAlphabet subSymbols = (FiniteAlphabet)sym.getMatches();
119+
for (Iterator i2 = subSymbols.iterator(); i2.hasNext(); ) {
120+
AtomicSymbol sym2 = (AtomicSymbol)i2.next();
121+
counts.increaseCount(sym2, 1.0 / (double)subSymbols.size());
122+
}
123+
}
124+
}
125+
126+
//agora imprime os resultados
127+
for (Iterator i = ((FiniteAlphabet)counts.getAlphabet()).iterator();
128+
i.hasNext(); ) {
129+
AtomicSymbol sym = (AtomicSymbol)i.next();
130+
System.out.println(sym.getName()+" : "+counts.getCount(sym));
131+
}
132+
}
133+
catch (Exception ex) {
134+
ex.printStackTrace();
135+
}
136+
}
137+
}
138+
</java>

0 commit comments

Comments
 (0)