「基因Java」基因JAK2基因V617F突变
今天给各位分享基因Java的知识，其中也会对基因JAK2基因V617F突变进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、2021-05-27 基因组共线性
- 2、Java 找基因问题 看一下程序的错误
- 3、java中怎么求基因检测问题 用一个字符串表示一段基因，例如：“CTATGGGTTT”。两段基因的相似度定义为它们
- 4、如何用Java实现遗传算法？
2021-05-27 基因组共线性
source ：
Mr_我爱读文献
最近看了几篇关于共线性分析的微信/推送，发现不少研究人员把“编码基因共线性”错误地描述为“全基因组共线性”。这是两个完全不同的概念，前者主要是基于蛋白水平，蛋白的保守性很高，即使分化较远的物种间也能找到同源基因片段；而后者则是基于DNA水平，其中包含了大量的非编码片段，变异程度即使是在近缘物种间也非常大。那么，接下来就好好聊一聊什么是共线性？为什么进行全基因组共线性分析？以及如何进行全基因组共线性分析？
1. 共线性
所谓的共线性主要是用来描述同一染色体上基因的位置关系，也就是指由同一祖先型分化而来的不同物种间基因的类型以及相对顺序的保守性（即 基因的同源性+基因的排列顺序 ）。共线性片段的大小与物种之间的分化时间有很大关系：分化时间较短的物种间，积累的变异较少，会保留更多从祖先遗传下来的特征；相反的，分化时间较长的物种间由于变异积累而导致共有的特征变少，反而获得较短的共线性片段。此外，基因同源又可以分为直系同源和旁系同源。直系同源基因指存在于祖先基因组中，随后因为物种分化，分别遗传给不同的后代，这些基因在结构和功能上有很高的相似性。旁系同源基因指同一基因组中由于基因复制而产生的的同源基因，这些基因往往变异较大，从而可能出现功能变异。
2.共线性分析的应用
测序发展初期，人们只能测得部分序列，但这些数据量少，不利于全面分析基因功能。另外，单个物种基因组序列也无法完整的描述该物种的全面信息，而且也无法挖掘真正的进化事件，比如基因丢失、基因获得等。近几年，随着测序技术的快速发展，为大规模的全基因组测序创造了很好的条件。而比较基因组的出现，更是进一步推动了近缘物种或个体的全基因组测序，其中比较基因组中很大的一部分工作就是集中在全基因组比对上。
共线性分析是比较基因组中必不可少的分析策略，因为它允许分析物种间大尺度和小尺度的分子进化事件。大尺度进化事件主要包括对基因组内重排和复制事件的估计，例如，可以使用人与小鼠之间的全基因组比对来识别共线性同源区块，然后确定重排事件，从而解释两个基因组结构差异。小尺度进化事件则是针对基因组水平的碱基替换速率以及插入、缺失事件。从共线性片段中可以识别出的物种间小尺度和大尺度突变事件，这些都可以作为物种树推断数据。此外，结合构建的两个尺度的基因组进化模型，共线性比对还能够完成祖先基因组重建的任务。
由于基因组共线性通常可以预测同源序列，并且同源序列可能具有相似的功能，因此全基因组共线性分析对于功能预测是十分有价值的。可以通过在整个基因组的核苷酸水平上对齐，从而可以帮助预测编码和非编码区域的功能。 例如，如果我们对人类基因组中特定的疾病相关区域感兴趣，我们可能会使用对齐来识别其小鼠同源基因的位置。 通过对小鼠同源片段的了解将使我们能够更好地了解这个基因组区域的进化历史，并可能进行遗传操作实验。
3.基因组共线性比对工具
全基因组比对需要消耗的计算机内存很大，而且运行时间较长。另外，由于基因组复制事件广泛存在，尤其是植物基因组，可能无法很好地区分旁系同源基因，容易产生大量的假阳性比对结果。因此，选择合适的基因组比对软件尤其重要。目前比较成熟的基于全基因组共线性比对分析的软件有：MUMmer、progressiveMauve、Mugsy、LAST、Lastz、Cactus。
MUMmer MUMmer是一种非常快速的pairwise基因组比对工具，能够在四个小时内完成人类和黑猩猩的全基因组比对。它是通过使用后缀树数据结构来找到两个基因组之间的所有最大唯一匹配，从而达到了这一速度。MUMmer适用于非常近缘物种之间的基因组比对，尽管速度较快，但其灵敏度比LAST/lastZ要低。
** progressiveMauve progressiveMauve是一款以java编写的全基因组比对软件，具有可视化界面，便于之间查看比对结果，比对效果较好适用于细菌基因组的比对。此外，需要注意的是progressiveMauve采用的比对策略是无参比对。
Mugsy Mugsy比对速度快，效率高，而且比对的长度较长，但主要适用于近缘物种之间的比较，对于进化距离较远的物种比对效果不太理想。
LAST LAST的优势在于能够处理较大基因组（如脊椎动物基因组）之间的比较，而且具有很快的比对速度。但是，它目前还无法进行有gap的比对，这也在一定程度上导致它的比对长度较短，数量较多。另外，LAST能够有效的处理含有重复序列的区域，因为它采用的是可变长度的种子序列，大大改善了比对的效率。
Lastz Lastz相比于LAST而言，它能够允许基因组中少量gap的存在，比对长度较长，适用远缘物种之间的全基因组比对（如脊椎动物），其灵敏度稍稍低于LAST，速度也要比LAST慢一些。
Cactus Cactus主程序其实是打包了Lastz，但是它自身又采用了无参比对的策略，可以直接重构祖先的染色体序列。
值得推荐的软件： LAST、Lastz、Cactus
参考链接：
链接：
Java 找基因问题 看一下程序的错误
问题有几个地方看不懂啊，你能不能用通俗点的语言解释一下，我生物是高中水平
如果基因不包含任何ATG, TAG, TAA和TGA这样的三字符会怎样，你的bcd比较完大小之后的s干什么的
应该是ATG到TAG或TAA或TGA的长度是3的倍数吧
java中怎么求基因检测问题 用一个字符串表示一段基因，例如：“CTATGGGTTT”。两段基因的相似度定义为它们
public class test{
public static void main(String args[]){
String a="CTATGGGTTT";
String b="QBATGAFETF";
float f;
float t=0;
for(int i=0;ia.length();i++){
if(a.charAt(i)==b.charAt(i))
t++;
}
f=t/a.length();
System.out.println("相似度："+f*100+"%");
}
}
如何用Java实现遗传算法？
通过遗传算法走迷宫。虽然图1和图2均成功走出迷宫，但是图1比图2的路径长的多，且复杂，遗传算法可以计算出有多少种可能性，并选择其中最简洁的作为运算结果。
示例图1：
示例图2：
实现代码：
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
/**
* 用遗传算法走迷宫
*
* @author Orisun
*
*/
public class GA {
int gene_len; // 基因长度
int chrom_len; // 染色体长度
int population; // 种群大小
double cross_ratio; // 交叉率
double muta_ratio; // 变异率
int iter_limit; // 最多进化的代数
Listboolean[] individuals; // 存储当代种群的染色体
Labyrinth labyrinth;
int width; //迷宫一行有多少个格子
int height; //迷宫有多少行
public class BI {
double fitness;
boolean[] indv;
public BI(double f, boolean[] ind) {
fitness = f;
indv = ind;
}
public double getFitness() {
return fitness;
}
public boolean[] getIndv() {
return indv;
}
}
ListBI best_individual; // 存储每一代中最优秀的个体
public GA(Labyrinth labyrinth) {
this.labyrinth=labyrinth;
this.width = labyrinth.map[0].length;
this.height = labyrinth.map.length;
chrom_len = 4 * (width+height);
gene_len = 2;
population = 20;
cross_ratio = 0.83;
muta_ratio = 0.002;
iter_limit = 300;
individuals = new ArrayListboolean[](population);
best_individual = new ArrayListBI(iter_limit);
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public double getCross_ratio() {
return cross_ratio;
}
public ListBI getBest_individual() {
return best_individual;
}
public Labyrinth getLabyrinth() {
return labyrinth;
}
public void setLabyrinth(Labyrinth labyrinth) {
this.labyrinth = labyrinth;
}
public void setChrom_len(int chrom_len) {
this.chrom_len = chrom_len;
}
public void setPopulation(int population) {
this.population = population;
}
public void setCross_ratio(double cross_ratio) {
this.cross_ratio = cross_ratio;
}
public void setMuta_ratio(double muta_ratio) {
this.muta_ratio = muta_ratio;
}
public void setIter_limit(int iter_limit) {
this.iter_limit = iter_limit;
}
// 初始化种群
public void initPopulation() {
Random r = new Random(System.currentTimeMillis());
for (int i = 0; i population; i++) {
int len = gene_len * chrom_len;
boolean[] ind = new boolean[len];
for (int j = 0; j len; j++)
ind[j] = r.nextBoolean();
individuals.add(ind);
}
}
// 交叉
public void cross(boolean[] arr1, boolean[] arr2) {
Random r = new Random(System.currentTimeMillis());
int length = arr1.length;
int slice = 0;
do {
slice = r.nextInt(length);
} while (slice == 0);
if (slice length / 2) {
for (int i = 0; i slice; i++) {
boolean tmp = arr1[i];
arr1[i] = arr2[i];
arr2[i] = tmp;
}
} else {
for (int i = slice; i length; i++) {
boolean tmp = arr1[i];
arr1[i] = arr2[i];
arr2[i] = tmp;
}
}
}
// 变异
public void mutation(boolean[] individual) {
int length = individual.length;
Random r = new Random(System.currentTimeMillis());
individual[r.nextInt(length)] ^= false;
}
// 轮盘法选择下一代,并返回当代最高的适应度值
public double selection() {
boolean[][] next_generation = new boolean[population][]; // 下一代
int length = gene_len * chrom_len;
for (int i = 0; i population; i++)
next_generation[i] = new boolean[length];
double[] cumulation = new double[population];
int best_index = 0;
double max_fitness = getFitness(individuals.get(best_index));
cumulation[0] = max_fitness;
for (int i = 1; i population; i++) {
double fit = getFitness(individuals.get(i));
cumulation[i] = cumulation[i - 1] + fit;
// 寻找当代的最优个体
if (fit max_fitness) {
best_index = i;
max_fitness = fit;
}
}
Random rand = new Random(System.currentTimeMillis());
for (int i = 0; i population; i++)
next_generation[i] = individuals.get(findByHalf(cumulation,
rand.nextDouble() * cumulation[population - 1]));
// 把当代的最优个体及其适应度放到best_individual中
BI bi = new BI(max_fitness, individuals.get(best_index));
// printPath(individuals.get(best_index));
//System.out.println(max_fitness);
best_individual.add(bi);
// 新一代作为当前代
for (int i = 0; i population; i++)
individuals.set(i, next_generation[i]);
return max_fitness;
}
// 折半查找
public int findByHalf(double[] arr, double find) {
if (find 0 || find == 0 || find arr[arr.length - 1])
return -1;
int min = 0;
int max = arr.length - 1;
int medium = min;
do {
if (medium == (min + max) / 2)
break;
medium = (min + max) / 2;
if (arr[medium] find)
min = medium;
else if (arr[medium] find)
max = medium;
else
return medium;
} while (min max);
return max;
}
// 计算适应度
public double getFitness(boolean[] individual) {
int length = individual.length;
// 记录当前的位置,入口点是（1,0）
int x = 1;
int y = 0;
// 根据染色体中基因的指导向前走
for (int i = 0; i length; i++) {
boolean b1 = individual[i];
boolean b2 = individual[++i];
// 00向左走
if (b1 == false b2 == false) {
if (x 0 labyrinth.map[y][x - 1] == true) {
x--;
}
}
// 01向右走
else if (b1 == false b2 == true) {
if (x + 1 width labyrinth.map[y][x + 1] == true) {
x++;
}
}
// 10向上走
else if (b1 == true b2 == false) {
if (y 0 labyrinth.map[y - 1][x] == true) {
y--;
}
}
// 11向下走
else if (b1 == true b2 == true) {
if (y + 1 height labyrinth.map[y + 1][x] == true) {
y++;
}
}
}
int n = Math.abs(x - labyrinth.x_end) + Math.abs(y -labyrinth.y_end) + 1;
// if(n==1)
// printPath(individual);
return 1.0 / n;
}
// 运行遗传算法
public boolean run() {
// 初始化种群
initPopulation();
Random rand = new Random(System.currentTimeMillis());
boolean success = false;
while (iter_limit-- 0) {
// 打乱种群的顺序
Collections.shuffle(individuals);
for (int i = 0; i population - 1; i += 2) {
// 交叉
if (rand.nextDouble() cross_ratio) {
cross(individuals.get(i), individuals.get(i + 1));
}
// 变异
if (rand.nextDouble() muta_ratio) {
mutation(individuals.get(i));
}
}
// 种群更替
if (selection() == 1) {
success = true;
break;
}
}
return success;
}
// public static void main(String[] args) {
// GA ga = new GA(8, 8);
// if (!ga.run()) {
// System.out.println("没有找到走出迷宫的路径.");
// } else {
// int gen = ga.best_individual.size();
// boolean[] individual = ga.best_individual.get(gen - 1).indv;
// System.out.println(ga.getPath(individual));
// }
// }
// 根据染色体打印走法
public String getPath(boolean[] individual) {
int length = individual.length;
int x = 1;
int y = 0;
LinkedListString stack=new LinkedListString();
for (int i = 0; i length; i++) {
boolean b1 = individual[i];
boolean b2 = individual[++i];
if (b1 == false b2 == false) {
if (x 0 labyrinth.map[y][x - 1] == true) {
x--;
if(!stack.isEmpty() stack.peek()=="右")
stack.poll();
else
stack.push("左");
}
} else if (b1 == false b2 == true) {
if (x + 1 width labyrinth.map[y][x + 1] == true) {
x++;
if(!stack.isEmpty() stack.peek()=="左")
stack.poll();
else
stack.push("右");
}
} else if (b1 == true b2 == false) {
if (y 0 labyrinth.map[y - 1][x] == true) {
y--;
if(!stack.isEmpty() stack.peek()=="下")
stack.poll();
else
stack.push("上");
}
} else if (b1 == true b2 == true) {
if (y + 1 height labyrinth.map[y + 1][x] == true) {
y++;
if(!stack.isEmpty() stack.peek()=="上")
stack.poll();
else
stack.push("下");
}
}
}
StringBuilder sb=new StringBuilder(length/4);
IteratorString iter=stack.descendingIterator();
while(iter.hasNext())
sb.append(iter.next());
return sb.toString();
}
}
基因Java的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于基因JAK2基因V617F突变、基因Java的信息别忘了在本站进行查找喔。